@semapps/semantic-data-provider 1.0.3 → 1.1.0-patch.1

package/dist/index.cjs.js

@@ -1,10 +1,13 @@
-var $bkNnK$urljoin = require("url-join");
+var $bkNnK$speakingurl = require("speakingurl");
 var $bkNnK$jsonld = require("jsonld");
 var $bkNnK$rdfjsdatamodel = require("@rdfjs/data-model");
 var $bkNnK$sparqljs = require("sparqljs");
 var $bkNnK$cryptojsmd5 = require("crypto-js/md5");
-var $bkNnK$jwtdecode = require("jwt-decode");
 var $bkNnK$reactadmin = require("react-admin");
+var $bkNnK$urljoin = require("url-join");
+var $bkNnK$jwtdecode = require("jwt-decode");
+var $bkNnK$httplinkheader = require("http-link-header");
+var $bkNnK$changecase = require("change-case");
 var $bkNnK$react = require("react");
 var $bkNnK$reactjsxruntime = require("react/jsx-runtime");
 var $bkNnK$muistylesmakeStyles = require("@mui/styles/makeStyles");
@@ -38,13 +41,25 @@ function $parcel$interopDefault(a) {
 $parcel$export(module.exports, "dataProvider", () => $7f6a16d0025dc83a$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "buildSparqlQuery", () => $33c37185da3771a9$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "buildBlankNodesQuery", () => $64d4ce40c79d1509$export$2e2bcd8739ae039);
-$parcel$export(module.exports, "useGetExternalLink", () => $85e9a897c6d7c14a$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "getUriFromPrefix", () => $108795c3831be99f$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "getPrefixFromUri", () => $8c4c0f0b55649ce6$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "configureUserStorage", () => $89358cee13a17a31$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "fetchAppRegistration", () => $c512de108ef5d674$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "fetchDataRegistry", () => $cd772adda3024172$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "fetchTypeIndexes", () => $69d4da9beaa62ac6$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "fetchVoidEndpoints", () => $1395e306228d41f2$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "useCompactPredicate", () => $9d33c8835e67bede$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "useContainers", () => $3158e0dc13ffffaa$export$2e2bcd8739ae039);
-$parcel$export(module.exports, "useCreateContainer", () => $99ed32cbdb76cb50$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "useContainersByTypes", () => $21fb109d85e9c16c$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "useContainerByUri", () => $d3746ce11bc56f3b$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "useCreateContainerUri", () => $298b78bb7d4a3358$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "useDataModel", () => $63a32f1a35c6f80e$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "useDataModels", () => $20621bc841a5205a$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "useDataProviderConfig", () => $9def35f4441a9bb2$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "useDataServers", () => $c9933a88e2acc4da$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "useGetCreateContainerUri", () => $32d32215b4e4729f$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "useGetExternalLink", () => $85e9a897c6d7c14a$export$2e2bcd8739ae039);
+$parcel$export(module.exports, "useGetPrefixFromUri", () => $d602250066d4ff3e$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "FilterHandler", () => $f763906f9b20f2d8$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "GroupedReferenceHandler", () => $b4703fef6d6af456$export$2e2bcd8739ae039);
 $parcel$export(module.exports, "ReificationArrayInput", () => $030f1232f6810456$export$2e2bcd8739ae039);
@@ -60,10 +75,10 @@ const $3db7a4510a668a04$var$fetchResource = async (resourceUri, config)=>{
     const { httpClient: httpClient, jsonContext: jsonContext } = config;
     let { json: data } = await httpClient(resourceUri);
     if (!data) throw new Error(`Not a valid JSON: ${resourceUri}`);
-    data.id = data.id || data["@id"];
+    data.id = data.id || data['@id'];
     // We compact only if the context is different between the frontend and the middleware
     // TODO deep compare if the context is an object
-    if (data["@context"] !== jsonContext) data = await (0, ($parcel$interopDefault($bkNnK$jsonld))).compact(data, jsonContext);
+    if (data['@context'] !== jsonContext) data = await (0, ($parcel$interopDefault($bkNnK$jsonld))).compact(data, jsonContext);
     return data;
 };
 var $3db7a4510a668a04$export$2e2bcd8739ae039 = $3db7a4510a668a04$var$fetchResource;
@@ -105,36 +120,40 @@ const $9020b8e3f4a4c1a1$var$getOneMethod = (config)=>async (resourceId, params)=
 var $9020b8e3f4a4c1a1$export$2e2bcd8739ae039 = $9020b8e3f4a4c1a1$var$getOneMethod;
 
 
+const $0edd1f2d07c8231f$var$getUploadsContainerUri = (config, serverKey)=>{
+    // If no server key is defined or if the server has no uploads container, find any server with a uploads container
+    if (!serverKey || !config.dataServers[serverKey].containers || !config.dataServers[serverKey].containers?.find((c)=>c.binaryResources)) serverKey = Object.keys(config.dataServers).find((key)=>config.dataServers[key].containers?.find((c)=>c.binaryResources));
+    if (serverKey) return config.dataServers[serverKey].containers?.find((c)=>c.binaryResources)?.uri;
+    else // No server has an uploads container
+    return null;
+};
+var $0edd1f2d07c8231f$export$2e2bcd8739ae039 = $0edd1f2d07c8231f$var$getUploadsContainerUri;
+
 
 const $6fcb30f76390d142$var$isFile = (o)=>o?.rawFile && o.rawFile instanceof File;
 const $6fcb30f76390d142$var$isFileToDelete = (o)=>o?.fileToDelete !== undefined && o?.fileToDelete !== null;
-const $6fcb30f76390d142$var$getUploadsContainerUri = (config)=>{
-    const serverKey = Object.keys(config.dataServers).find((key)=>config.dataServers[key].uploadsContainer);
-    if (serverKey && config.dataServers[serverKey].uploadsContainer) return (0, ($parcel$interopDefault($bkNnK$urljoin)))(config.dataServers[serverKey].baseUrl, config.dataServers[serverKey].uploadsContainer);
-    return null;
-};
-const $6fcb30f76390d142$export$a5575dbeeffdad98 = async (rawFile, config)=>{
-    const uploadsContainerUri = $6fcb30f76390d142$var$getUploadsContainerUri(config);
-    if (!uploadsContainerUri) throw new Error("You must define an uploadsContainer in one of the server's configuration");
+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");
     const response = await config.httpClient(uploadsContainerUri, {
-        method: "POST",
+        method: 'POST',
         body: rawFile,
         headers: new Headers({
-            "Content-Type": rawFile.type
+            'Content-Type': rawFile.type
         })
     });
-    if (response.status === 201) return response.headers.get("Location");
+    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"
+            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)=>{
+ */ const $6fcb30f76390d142$var$uploadAllFiles = async (record, config, serverKey)=>{
     const filesToDelete = [];
     const updatedRecord = {
         ...record
@@ -145,7 +164,7 @@ const $6fcb30f76390d142$var$deleteFiles = async (filesToDelete, config)=>{
             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);
+                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;
@@ -153,7 +172,7 @@ const $6fcb30f76390d142$var$deleteFiles = async (filesToDelete, config)=>{
         }
         else if ($6fcb30f76390d142$var$isFile(value)) {
             if ($6fcb30f76390d142$var$isFileToDelete(value)) filesToDelete.push(value.fileToDelete);
-            updatedRecord[property] = await $6fcb30f76390d142$export$a5575dbeeffdad98(value.rawFile, config);
+            updatedRecord[property] = await $6fcb30f76390d142$export$a5575dbeeffdad98(value.rawFile, config, serverKey);
         } else if ($6fcb30f76390d142$var$isFileToDelete(value)) {
             filesToDelete.push(value.fileToDelete);
             updatedRecord[property] = null;
@@ -170,74 +189,72 @@ var $6fcb30f76390d142$export$2e2bcd8739ae039 = {
 };
 
 
-
 const $8f44b7c15b8b8e1d$var$getServerKeyFromType = (type, dataServers)=>{
-    return Object.keys(dataServers).find((key)=>{
+    return dataServers && Object.keys(dataServers).find((key)=>{
         return dataServers[key][type];
     });
 };
 var $8f44b7c15b8b8e1d$export$2e2bcd8739ae039 = $8f44b7c15b8b8e1d$var$getServerKeyFromType;
 
 
-const $982f4f2fb185d606$var$parseServerKey = (serverKey, dataServers)=>{
+const $6531da3b9e8c524a$var$parseServerKey = (serverKey, dataServers)=>{
     switch(serverKey){
-        case "@default":
-            return (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("default", dataServers);
-        case "@pod":
-            return (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("pod", dataServers);
-        case "@authServer":
-            return (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("authServer", dataServers);
+        case '@default':
+            return (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)('default', dataServers);
+        case '@pod':
+            return (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)('pod', dataServers);
+        case '@authServer':
+            return (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)('authServer', dataServers);
         default:
             return serverKey;
     }
 };
 // Return the list of servers keys in an array
 // parsing keywords like @all, @default, @pod and @authServer
-const $982f4f2fb185d606$var$parseServerKeys = (serverKeys, dataServers)=>{
+const $6531da3b9e8c524a$var$parseServerKeys = (serverKeys, dataServers)=>{
     if (Array.isArray(serverKeys)) {
-        if (serverKeys.includes("@all")) return Object.keys(dataServers);
-        return serverKeys.map((serverKey)=>$982f4f2fb185d606$var$parseServerKey(serverKey, dataServers));
-    }
-    if (typeof serverKeys === "string") {
-        if (serverKeys === "@all") return Object.keys(dataServers);
-        if (serverKeys === "@remote") {
-            const defaultServerKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("default", dataServers);
+        if (serverKeys.includes('@all')) return Object.keys(dataServers);
+        else return serverKeys.map((serverKey)=>$6531da3b9e8c524a$var$parseServerKey(serverKey, dataServers));
+    } else if (typeof serverKeys === 'string') {
+        if (serverKeys === '@all') return Object.keys(dataServers);
+        else if (serverKeys === '@remote') {
+            const defaultServerKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)('default', dataServers);
             return Object.keys(dataServers).filter((serverKey)=>serverKey !== defaultServerKey);
-        }
-        return [
-            $982f4f2fb185d606$var$parseServerKey(serverKeys, dataServers)
+        } else return [
+            $6531da3b9e8c524a$var$parseServerKey(serverKeys, dataServers)
         ];
-    }
-    // If server key is empty
-    return false;
+    } else throw new Error(`The parseServerKeys expect a list of server keys, or keywords`);
 };
-var $982f4f2fb185d606$export$2e2bcd8739ae039 = $982f4f2fb185d606$var$parseServerKeys;
-
-
-const $047a107b0d203793$var$findContainersWithTypes = (types, serverKeys, dataServers)=>{
-    const containers = {};
-    const existingContainers = [];
-    const parsedServerKeys = (0, $982f4f2fb185d606$export$2e2bcd8739ae039)(serverKeys, dataServers);
-    Object.keys(dataServers).filter((dataServerKey)=>dataServers[dataServerKey].containers).forEach((dataServerKey)=>{
-        Object.keys(dataServers[dataServerKey].containers || {}).forEach((containerKey)=>{
-            if (!parsedServerKeys || parsedServerKeys.includes(containerKey)) Object.keys(dataServers[dataServerKey].containers[containerKey]).forEach((type)=>{
-                if (types.includes(type)) dataServers[dataServerKey].containers[containerKey][type].map((path)=>{
-                    const containerUri = (0, ($parcel$interopDefault($bkNnK$urljoin)))(dataServers[containerKey].baseUrl, path);
-                    // Avoid returning the same container several times
-                    if (!existingContainers.includes(containerUri)) {
-                        existingContainers.push(containerUri);
-                        if (!containers[dataServerKey]) containers[dataServerKey] = [];
-                        containers[dataServerKey].push(containerUri);
-                    }
-                });
-            });
+var $6531da3b9e8c524a$export$2e2bcd8739ae039 = $6531da3b9e8c524a$var$parseServerKeys;
+
+
+/**
+ * Return all containers matching the given types
+ */ const $047a107b0d203793$var$findContainersWithTypes = (types, serverKeys, dataServers)=>{
+    const matchingContainers = [];
+    const parsedServerKeys = (0, $6531da3b9e8c524a$export$2e2bcd8739ae039)(serverKeys || '@all', dataServers);
+    Object.keys(dataServers).forEach((dataServerKey)=>{
+        if (parsedServerKeys.includes(dataServerKey)) dataServers[dataServerKey].containers?.forEach((container)=>{
+            if (container.types?.some((t)=>types.includes(t))) matchingContainers.push(container);
         });
     });
-    return containers;
+    return matchingContainers;
 };
 var $047a107b0d203793$export$2e2bcd8739ae039 = $047a107b0d203793$var$findContainersWithTypes;
 
 
+const $37c161736d0d7276$var$findContainersWithURIs = (containersUris, dataServers)=>{
+    const matchingContainers = [];
+    Object.keys(dataServers).forEach((serverKey)=>{
+        dataServers[serverKey].containers?.forEach((container)=>{
+            if (container.uri && containersUris.includes(container.uri)) matchingContainers.push(container);
+        });
+    });
+    return matchingContainers;
+};
+var $37c161736d0d7276$export$2e2bcd8739ae039 = $37c161736d0d7276$var$findContainersWithURIs;
+
+
 const $907cbc087f6529e2$var$createMethod = (config)=>async (resourceId, params)=>{
         const { dataServers: dataServers, resources: resources, httpClient: httpClient, jsonContext: jsonContext } = config;
         const dataModel = resources[resourceId];
@@ -246,47 +263,49 @@ const $907cbc087f6529e2$var$createMethod = (config)=>async (resourceId, params)=
         let containerUri;
         let serverKey;
         if (dataModel.create?.container) {
-            serverKey = Object.keys(dataModel.create.container)[0];
-            containerUri = (0, ($parcel$interopDefault($bkNnK$urljoin)))(dataServers[serverKey].baseUrl, Object.values(dataModel.create.container)[0]);
+            const [container] = (0, $37c161736d0d7276$export$2e2bcd8739ae039)([
+                dataModel.create?.container
+            ], dataServers);
+            serverKey = container.server;
+            containerUri = container.uri;
         } else {
             serverKey = dataModel.create?.server || Object.keys(dataServers).find((key)=>dataServers[key].default === true);
-            if (!serverKey) throw new Error("You must define a server for the creation, or a container, or a default server");
+            if (!serverKey) throw new Error('You must define a server for the creation, or a container, or a default server');
             const containers = (0, $047a107b0d203793$export$2e2bcd8739ae039)(dataModel.types, [
                 serverKey
             ], dataServers);
-            // Extract the containerUri from the results (and ensure there is only one)
-            const serverKeys = Object.keys(containers);
-            if (!serverKeys || serverKeys.length === 0) throw new Error(`No container with types ${JSON.stringify(dataModel.types)} found on server ${serverKey}`);
-            if (serverKeys.length > 1 || containers[serverKeys[0]].length > 1) throw new Error(`More than one container detected with types ${JSON.stringify(dataModel.types)} on server ${serverKey}`);
-            containerUri = containers[serverKeys[0]][0];
+            if (!containers || containers.length === 0) throw new Error(`No container with types ${JSON.stringify(dataModel.types)} found on server ${serverKey}`);
+            if (containers.length > 1) throw new Error(`More than one container detected with types ${JSON.stringify(dataModel.types)} on server ${serverKey}`);
+            containerUri = containers[0].uri;
         }
         if (params.data) {
             if (dataModel.fieldsMapping?.title) {
-                if (Array.isArray(dataModel.fieldsMapping.title)) headers.set("Slug", dataModel.fieldsMapping.title.map((f)=>params.data[f]).join(" "));
-                else headers.set("Slug", params.data[dataModel.fieldsMapping.title]);
+                const slug = Array.isArray(dataModel.fieldsMapping.title) ? dataModel.fieldsMapping.title.map((f)=>params.data[f]).join(' ') : params.data[dataModel.fieldsMapping.title];
+                // Generate slug here, otherwise we may get errors with special characters
+                headers.set('Slug', (0, ($parcel$interopDefault($bkNnK$speakingurl)))(slug));
             }
             // Upload files, if there are any
-            const { updatedRecord: updatedRecord } = await (0, $6fcb30f76390d142$export$2e2bcd8739ae039).upload(params.data, config);
+            const { updatedRecord: updatedRecord } = await (0, $6fcb30f76390d142$export$2e2bcd8739ae039).upload(params.data, config, serverKey);
             params.data = updatedRecord;
             const { headers: responseHeaders } = await httpClient(containerUri, {
-                method: "POST",
+                method: 'POST',
                 headers: headers,
                 body: JSON.stringify({
-                    "@context": jsonContext,
-                    "@type": dataModel.types,
+                    '@context': jsonContext,
+                    '@type': dataModel.types,
                     ...params.data
                 })
             });
             // Retrieve newly-created resource
-            const resourceUri = responseHeaders.get("Location");
+            const resourceUri = responseHeaders.get('Location');
             return await (0, $9020b8e3f4a4c1a1$export$2e2bcd8739ae039)(config)(resourceId, {
                 id: resourceUri
             });
         }
         if (params.id) {
-            headers.set("Content-Type", "application/sparql-update");
+            headers.set('Content-Type', 'application/sparql-update');
             await httpClient(containerUri, {
-                method: "PATCH",
+                method: 'PATCH',
                 headers: headers,
                 body: `
         PREFIX ldp: <http://www.w3.org/ns/ldp#>
@@ -306,7 +325,7 @@ var $907cbc087f6529e2$export$2e2bcd8739ae039 = $907cbc087f6529e2$var$createMetho
 const $566b5adde94810fa$var$deleteMethod = (config)=>async (resourceId, params)=>{
         const { httpClient: httpClient } = config;
         await httpClient(`${params.id}`, {
-            method: "DELETE"
+            method: 'DELETE'
         });
         if (params.meta?.filesToDelete) await (0, $6fcb30f76390d142$export$2e2bcd8739ae039).delete(params.meta.filesToDelete, config);
         return {
@@ -323,7 +342,7 @@ const $f170294dd29d8bf8$var$deleteManyMethod = (config)=>async (resourceId, para
         const ids = [];
         for (const id of params.ids)try {
             await httpClient(id, {
-                method: "DELETE"
+                method: 'DELETE'
             });
             ids.push(id);
         } catch (e) {
@@ -364,24 +383,23 @@ var $e6fbab1f303bdb93$export$2e2bcd8739ae039 = $e6fbab1f303bdb93$var$arrayOf;
 
 
 const $8c999cc29c8d6a6c$var$isValidLDPContainer = (container)=>{
-    const resourceType = container.type || container["@type"];
-    return Array.isArray(resourceType) ? resourceType.includes("ldp:Container") : resourceType === "ldp:Container";
+    const resourceType = container.type || container['@type'];
+    return Array.isArray(resourceType) ? resourceType.includes('ldp:Container') : resourceType === 'ldp:Container';
 };
 const $8c999cc29c8d6a6c$var$isObject = (val)=>{
-    return val != null && typeof val === "object" && !Array.isArray(val);
+    return val != null && typeof val === 'object' && !Array.isArray(val);
 };
 const $8c999cc29c8d6a6c$var$fetchContainers = async (containers, params, { httpClient: httpClient, jsonContext: jsonContext })=>{
-    const containersUri = Object.values(containers).flat();
-    const fetchPromises = containersUri.map((containerUri)=>httpClient(containerUri).then(async ({ json: json })=>{
+    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);
+            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(`${containerUri} is not a LDP container`);
-            return (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(json["ldp:contains"]).map((resource)=>({
-                    "@context": json["@context"],
+            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
                 }));
         }));
@@ -389,7 +407,7 @@ const $8c999cc29c8d6a6c$var$fetchContainers = async (containers, params, { httpC
     const results = await Promise.all(fetchPromises);
     let resources = results.flat();
     resources = resources.map((resource)=>{
-        resource.id = resource.id || resource["@id"];
+        resource.id = resource.id || resource['@id'];
         return resource;
     });
     // Apply filter to results
@@ -403,20 +421,20 @@ const $8c999cc29c8d6a6c$var$fetchContainers = async (containers, params, { httpC
     if (filters._predicates && Array.isArray(filters._predicates)) {
         const predicates = filters._predicates;
         const mandatoryAttributes = [
-            "id"
+            'id'
         ];
         resources = resources.map((resource)=>{
             return Object.keys(resource).filter((key)=>predicates.includes(key) || mandatoryAttributes.includes(key)).reduce((filteredResource, key)=>{
                 filteredResource[key] = resource[key];
                 return filteredResource;
             }, {
-                "@context": []
+                '@context': []
             });
         });
     }
     if (Object.keys(filters).filter((f)=>![
-            "_predicates",
-            "_servers"
+            '_predicates',
+            '_servers'
         ].includes(f)).length > 0) resources = resources.filter((resource)=>{
         // Full text filtering
         if (filters.q) return Object.values(resource).some((attributeValue)=>{
@@ -425,7 +443,7 @@ const $8c999cc29c8d6a6c$var$fetchContainers = async (containers, params, { httpC
                     attributeValue
                 ];
                 return arrayValues.some((value)=>{
-                    if (typeof value === "string") return value.toLowerCase().normalize("NFD").includes(filters.q.toLowerCase().normalize("NFD"));
+                    if (typeof value === 'string') return value.toLowerCase().normalize('NFD').includes(filters.q.toLowerCase().normalize('NFD'));
                     return false;
                 });
             }
@@ -433,27 +451,24 @@ const $8c999cc29c8d6a6c$var$fetchContainers = async (containers, params, { httpC
         });
         // Attribute filtering
         const attributesFilters = Object.keys(filters).filter((f)=>![
-                "_predicates",
-                "_servers",
-                "q"
+                '_predicates',
+                '_servers',
+                'q'
             ].includes(f));
         return attributesFilters.every((attribute)=>{
             if (resource[attribute]) {
                 const arrayValues = Array.isArray(resource[attribute]) ? resource[attribute] : [
                     resource[attribute]
                 ];
-                return arrayValues.some((value)=>typeof value === "string" && value.includes(filters[attribute]));
+                return arrayValues.some((value)=>typeof value === 'string' && value.includes(filters[attribute]));
             }
             return false;
         });
     });
     // Sorting
     if (params.sort) resources = resources.sort((a, b)=>{
-        if (a[params.sort.field] && b[params.sort.field]) {
-            if (params.sort.order === "ASC") return a[params.sort.field].localeCompare(b[params.sort.field]);
-            return b[params.sort.field].localeCompare(a[params.sort.field]);
-        }
-        return true;
+        if (params.sort.order === 'ASC') return (a[params.sort.field] ?? '').localeCompare(b[params.sort.field] ?? '');
+        return (b[params.sort.field] ?? '').localeCompare(a[params.sort.field] ?? '');
     });
     // Pagination
     const total = resources.length;
@@ -472,7 +487,7 @@ const $e5241bff9fc0c9d7$var$getEmbedFrame = (blankNodes)=>{
     let predicates;
     if (blankNodes) {
         for (const blankNode of blankNodes){
-            if (blankNode.includes("/")) predicates = blankNode.split("/").reverse();
+            if (blankNode.includes('/')) predicates = blankNode.split('/').reverse();
             else predicates = [
                 blankNode
             ];
@@ -480,7 +495,7 @@ const $e5241bff9fc0c9d7$var$getEmbedFrame = (blankNodes)=>{
                 ...embedFrame,
                 ...predicates.reduce((accumulator, predicate)=>({
                         [predicate]: {
-                            "@embed": "@last",
+                            '@embed': '@last',
                             ...accumulator
                         }
                     }), {})
@@ -494,30 +509,31 @@ var $e5241bff9fc0c9d7$export$2e2bcd8739ae039 = $e5241bff9fc0c9d7$var$getEmbedFra
 
 
 
-const $761c677606459117$var$resolvePrefix = (item, ontologies)=>{
-    if (item.startsWith("http://") || item.startsWith("https://")) // Already resolved, return the URI
+const $108795c3831be99f$var$getUriFromPrefix = (item, ontologies)=>{
+    if (item.startsWith('http://') || item.startsWith('https://')) // Already resolved, return the URI
     return item;
-    if (item === "a") // Special case
-    return "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
-    const [prefix, value] = item.split(":");
-    if (value) {
-        const ontology = ontologies.find((ontology)=>ontology.prefix === prefix);
-        if (ontology) return ontology.url + value;
-        throw new Error(`No ontology found with prefix ${prefix}`);
-    } else throw new Error(`The value "${item}" is not correct. It must include a prefix or be a full URI.`);
+    else if (item === 'a') // Special case
+    return 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+    else {
+        const [prefix, value] = item.split(':');
+        if (value) {
+            if (ontologies[prefix]) return ontologies[prefix] + value;
+            else throw new Error(`No ontology found with prefix ${prefix}`);
+        } else throw new Error(`The value "${item}" is not correct. It must include a prefix or be a full URI.`);
+    }
 };
-var $761c677606459117$export$2e2bcd8739ae039 = $761c677606459117$var$resolvePrefix;
+var $108795c3831be99f$export$2e2bcd8739ae039 = $108795c3831be99f$var$getUriFromPrefix;
 
 
 const $51d7c29cc84f802b$var$defaultToArray = (value)=>!value ? [] : Array.isArray(value) ? value : [
         value
     ];
 // We need to always include the type or React-Admin will not work properly
-const $51d7c29cc84f802b$var$typeQuery = (0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)("s1"), (0, $bkNnK$rdfjsdatamodel.namedNode)("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), (0, $bkNnK$rdfjsdatamodel.variable)("type"));
+const $51d7c29cc84f802b$var$typeQuery = (0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)('s1'), (0, $bkNnK$rdfjsdatamodel.namedNode)('http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), (0, $bkNnK$rdfjsdatamodel.variable)('type'));
 const $51d7c29cc84f802b$var$buildBaseQuery = (predicates, ontologies)=>{
     let baseTriples;
     if (predicates) {
-        baseTriples = $51d7c29cc84f802b$var$defaultToArray(predicates).map((predicate, i)=>(0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)("s1"), (0, $bkNnK$rdfjsdatamodel.namedNode)((0, $761c677606459117$export$2e2bcd8739ae039)(predicate, ontologies)), (0, $bkNnK$rdfjsdatamodel.variable)(`o${i + 1}`)));
+        baseTriples = $51d7c29cc84f802b$var$defaultToArray(predicates).map((predicate, i)=>(0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)('s1'), (0, $bkNnK$rdfjsdatamodel.namedNode)((0, $108795c3831be99f$export$2e2bcd8739ae039)(predicate, ontologies)), (0, $bkNnK$rdfjsdatamodel.variable)(`o${i + 1}`)));
         return {
             construct: [
                 $51d7c29cc84f802b$var$typeQuery,
@@ -526,7 +542,7 @@ const $51d7c29cc84f802b$var$buildBaseQuery = (predicates, ontologies)=>{
             where: [
                 $51d7c29cc84f802b$var$typeQuery,
                 ...baseTriples.map((triple)=>({
-                        type: "optional",
+                        type: 'optional',
                         patterns: [
                             triple
                         ]
@@ -535,7 +551,7 @@ const $51d7c29cc84f802b$var$buildBaseQuery = (predicates, ontologies)=>{
         };
     }
     baseTriples = [
-        (0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)("s1"), (0, $bkNnK$rdfjsdatamodel.variable)("p1"), (0, $bkNnK$rdfjsdatamodel.variable)("o1"))
+        (0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)('s1'), (0, $bkNnK$rdfjsdatamodel.variable)('p1'), (0, $bkNnK$rdfjsdatamodel.variable)('o1'))
     ];
     return {
         construct: baseTriples,
@@ -552,22 +568,22 @@ var $51d7c29cc84f802b$export$2e2bcd8739ae039 = $51d7c29cc84f802b$var$buildBaseQu
 const $64d4ce40c79d1509$var$extractNodes = (blankNodes)=>{
     const nodes = [];
     if (blankNodes) {
-        for (const predicate of blankNodes)if (predicate.includes("/")) {
-            const nodeNames = predicate.split("/");
-            for(let i = 1; i <= nodeNames.length; i++)nodes.push(nodeNames.slice(0, i).join("/"));
+        for (const predicate of blankNodes)if (predicate.includes('/')) {
+            const nodeNames = predicate.split('/');
+            for(let i = 1; i <= nodeNames.length; i++)nodes.push(nodeNames.slice(0, i).join('/'));
         } else nodes.push(predicate);
     }
     return nodes;
 };
 const $64d4ce40c79d1509$var$generateSparqlVarName = (node)=>(0, ($parcel$interopDefault($bkNnK$cryptojsmd5)))(node);
-const $64d4ce40c79d1509$var$getParentNode = (node)=>node.includes("/") && node.split("/")[0];
-const $64d4ce40c79d1509$var$getPredicate = (node)=>node.includes("/") ? node.split("/")[1] : node;
+const $64d4ce40c79d1509$var$getParentNode = (node)=>node.includes('/') && node.split('/')[0];
+const $64d4ce40c79d1509$var$getPredicate = (node)=>node.includes('/') ? node.split('/')[1] : node;
 const $64d4ce40c79d1509$var$buildUnionQuery = (queries)=>queries.map((q)=>{
         let triples = q.query;
         const firstTriple = queries.find((q2)=>q.parentNode === q2.node);
         if (firstTriple !== undefined) triples = triples.concat(firstTriple.query[0]);
         return {
-            type: "bgp",
+            type: 'bgp',
             triples: triples
         };
     });
@@ -579,22 +595,22 @@ const $64d4ce40c79d1509$var$buildBlankNodesQuery = (blankNodes, baseQuery, ontol
             const parentNode = $64d4ce40c79d1509$var$getParentNode(node);
             const predicate = $64d4ce40c79d1509$var$getPredicate(node);
             const varName = $64d4ce40c79d1509$var$generateSparqlVarName(node);
-            const parentVarName = parentNode ? $64d4ce40c79d1509$var$generateSparqlVarName(parentNode) : "1";
+            const parentVarName = parentNode ? $64d4ce40c79d1509$var$generateSparqlVarName(parentNode) : '1';
             const query = [
-                (0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)(`s${parentVarName}`), (0, $bkNnK$rdfjsdatamodel.namedNode)((0, $761c677606459117$export$2e2bcd8739ae039)(predicate, ontologies)), (0, $bkNnK$rdfjsdatamodel.variable)(`s${varName}`)),
+                (0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)(`s${parentVarName}`), (0, $bkNnK$rdfjsdatamodel.namedNode)((0, $108795c3831be99f$export$2e2bcd8739ae039)(predicate, ontologies)), (0, $bkNnK$rdfjsdatamodel.variable)(`s${varName}`)),
                 (0, $bkNnK$rdfjsdatamodel.triple)((0, $bkNnK$rdfjsdatamodel.variable)(`s${varName}`), (0, $bkNnK$rdfjsdatamodel.variable)(`p${varName}`), (0, $bkNnK$rdfjsdatamodel.variable)(`o${varName}`))
             ];
             queries.push({
                 node: node,
                 parentNode: parentNode,
                 query: query,
-                filter: "" // `FILTER(isBLANK(?s${varName})) .`
+                filter: '' // `FILTER(isBLANK(?s${varName})) .`
             });
         }
         return {
             construct: queries.length > 0 ? queries.map((q)=>q.query).reduce((pre, cur)=>pre.concat(cur)) : null,
             where: {
-                type: "union",
+                type: 'union',
                 patterns: [
                     baseQuery.where,
                     ...$64d4ce40c79d1509$var$buildUnionQuery(queries)
@@ -603,8 +619,8 @@ const $64d4ce40c79d1509$var$buildBlankNodesQuery = (blankNodes, baseQuery, ontol
         };
     }
     return {
-        construct: "",
-        where: ""
+        construct: '',
+        where: ''
     };
 };
 var $64d4ce40c79d1509$export$2e2bcd8739ae039 = $64d4ce40c79d1509$var$buildBlankNodesQuery;
@@ -626,10 +642,10 @@ const $3b137d792e8838ac$var$buildAutoDetectBlankNodesQuery = (depth, baseQuery)=
             whereQueries.push([
                 ...whereQueries[whereQueries.length - 1],
                 {
-                    type: "filter",
+                    type: 'filter',
                     expression: {
-                        type: "operation",
-                        operator: "isblank",
+                        type: 'operation',
+                        operator: 'isblank',
                         args: [
                             (0, $bkNnK$rdfjsdatamodel.variable)(`o${i}`)
                         ]
@@ -639,11 +655,11 @@ const $3b137d792e8838ac$var$buildAutoDetectBlankNodesQuery = (depth, baseQuery)=
             ]);
         }
         where = {
-            type: "union",
+            type: 'union',
             patterns: whereQueries
         };
     } else if (depth === 0) where = baseQuery.where;
-    else throw new Error("The depth of buildAutoDetectBlankNodesQuery should be 0 or more");
+    else throw new Error('The depth of buildAutoDetectBlankNodesQuery should be 0 or more');
     return {
         construct: construct,
         where: where
@@ -659,14 +675,14 @@ const { literal: $33c37185da3771a9$var$literal, namedNode: $33c37185da3771a9$var
 const $33c37185da3771a9$var$generator = new $33c37185da3771a9$require$SparqlGenerator({
 });
 const $33c37185da3771a9$var$reservedFilterKeys = [
-    "q",
-    "sparqlWhere",
-    "blankNodes",
-    "blankNodesDepth",
-    "_servers",
-    "_predicates"
+    'q',
+    'sparqlWhere',
+    'blankNodes',
+    'blankNodesDepth',
+    '_servers',
+    '_predicates'
 ];
-const $33c37185da3771a9$var$buildSparqlQuery = ({ containers: containers, params: params, dataModel: dataModel, ontologies: ontologies })=>{
+const $33c37185da3771a9$var$buildSparqlQuery = ({ containersUris: containersUris, params: params, dataModel: dataModel, ontologies: ontologies })=>{
     const blankNodes = params.filter?.blankNodes || dataModel.list?.blankNodes;
     const predicates = params.filter?._predicates || dataModel.list?.predicates;
     const blankNodesDepth = params.filter?.blankNodesDepth ?? dataModel.list?.blankNodesDepth ?? 2;
@@ -676,99 +692,97 @@ const $33c37185da3771a9$var$buildSparqlQuery = ({ containers: containers, params
     };
     const baseQuery = (0, $51d7c29cc84f802b$export$2e2bcd8739ae039)(predicates, ontologies);
     const sparqlJsParams = {
-        queryType: "CONSTRUCT",
+        queryType: 'CONSTRUCT',
         template: baseQuery.construct,
         where: [],
-        type: "query",
-        prefixes: Object.fromEntries(ontologies.map((ontology)=>[
-                ontology.prefix,
-                ontology.url
-            ]))
+        type: 'query',
+        prefixes: ontologies
     };
     const containerWhere = [
         {
-            type: "values",
-            values: containers.map((containerUri)=>({
-                    "?containerUri": $33c37185da3771a9$var$namedNode(containerUri)
+            type: 'values',
+            values: containersUris.map((containerUri)=>({
+                    '?containerUri': $33c37185da3771a9$var$namedNode(containerUri)
                 }))
         },
-        $33c37185da3771a9$var$triple($33c37185da3771a9$var$variable("containerUri"), $33c37185da3771a9$var$namedNode("http://www.w3.org/ns/ldp#contains"), $33c37185da3771a9$var$variable("s1")),
+        $33c37185da3771a9$var$triple($33c37185da3771a9$var$variable('containerUri'), $33c37185da3771a9$var$namedNode('http://www.w3.org/ns/ldp#contains'), $33c37185da3771a9$var$variable('s1')),
         {
-            type: "filter",
+            type: 'filter',
             expression: {
-                type: "operation",
-                operator: "isiri",
+                type: 'operation',
+                operator: 'isiri',
                 args: [
-                    $33c37185da3771a9$var$variable("s1")
+                    $33c37185da3771a9$var$variable('s1')
                 ]
             }
         }
     ];
     let resourceWhere = [];
     if (filter && Object.keys(filter).length > 0) {
-        const hasSPARQLFilter = filter.sparqlWhere && Object.keys(filter.sparqlWhere).length > 0;
-        const hasFullTextSearch = filter.q && filter.q.length > 0;
-        if (hasSPARQLFilter) /*
-        Example of usage :
-        {
-          "sparqlWhere": {
-            "type": "bgp",
-            "triples": [{
-              "subject": {"termType": "Variable", "value": "s1"},
-              "predicate": {"termType": "NameNode", "value": "http://virtual-assembly.org/ontologies/pair#label"},
-              "object": {"termType": "Literal", "value": "My Organization"}
-            }]
-          }
+        /*
+      Example of usage :
+      {
+        "sparqlWhere": {
+          "type": "bgp",
+          "triples": [{
+            "subject": {"termType": "Variable", "value": "s1"},
+            "predicate": {"termType": "NameNode", "value": "http://virtual-assembly.org/ontologies/pair#label"},
+            "object": {"termType": "Literal", "value": "My Organization"}
+          }]
         }
-      */ // initialize array in case of single value :
-        [].concat(filter.sparqlWhere).forEach((sw)=>{
-            resourceWhere.push(sw);
-        });
-        if (hasFullTextSearch) resourceWhere.push({
-            type: "group",
+      }
+    */ if (filter.sparqlWhere) {
+            // When the SPARQL request comes from the browser's URL, it is a JSON string that must be parsed
+            const sparqlWhere = filter.sparqlWhere && (typeof filter.sparqlWhere === 'string' || filter.sparqlWhere instanceof String) ? JSON.parse(decodeURIComponent(filter.sparqlWhere)) : filter.sparqlWhere;
+            if (Object.keys(sparqlWhere).length > 0) [].concat(sparqlWhere).forEach((sw)=>{
+                resourceWhere.push(sw);
+            });
+        }
+        if (filter.q && filter.q.length > 0) resourceWhere.push({
+            type: 'group',
             patterns: [
                 {
-                    queryType: "SELECT",
+                    queryType: 'SELECT',
                     variables: [
-                        $33c37185da3771a9$var$variable("s1")
+                        $33c37185da3771a9$var$variable('s1')
                     ],
                     where: [
-                        $33c37185da3771a9$var$triple($33c37185da3771a9$var$variable("s1"), $33c37185da3771a9$var$variable("p1"), $33c37185da3771a9$var$variable("o1")),
+                        $33c37185da3771a9$var$triple($33c37185da3771a9$var$variable('s1'), $33c37185da3771a9$var$variable('p1'), $33c37185da3771a9$var$variable('o1')),
                         {
-                            type: "filter",
+                            type: 'filter',
                             expression: {
-                                type: "operation",
-                                operator: "isliteral",
+                                type: 'operation',
+                                operator: 'isliteral',
                                 args: [
-                                    $33c37185da3771a9$var$variable("o1")
+                                    $33c37185da3771a9$var$variable('o1')
                                 ]
                             }
                         },
                         {
-                            type: "filter",
+                            type: 'filter',
                             expression: {
-                                type: "operation",
-                                operator: "regex",
+                                type: 'operation',
+                                operator: 'regex',
                                 args: [
                                     {
-                                        type: "operation",
-                                        operator: "lcase",
+                                        type: 'operation',
+                                        operator: 'lcase',
                                         args: [
                                             {
-                                                type: "operation",
-                                                operator: "str",
+                                                type: 'operation',
+                                                operator: 'str',
                                                 args: [
-                                                    $33c37185da3771a9$var$variable("o1")
+                                                    $33c37185da3771a9$var$variable('o1')
                                                 ]
                                             }
                                         ]
                                     },
-                                    $33c37185da3771a9$var$literal(filter.q.toLowerCase(), "", $33c37185da3771a9$var$namedNode("http://www.w3.org/2001/XMLSchema#string"))
+                                    $33c37185da3771a9$var$literal(filter.q.toLowerCase(), '', $33c37185da3771a9$var$namedNode('http://www.w3.org/2001/XMLSchema#string'))
                                 ]
                             }
                         }
                     ],
-                    type: "query"
+                    type: 'query'
                 }
             ]
         });
@@ -776,7 +790,7 @@ const $33c37185da3771a9$var$buildSparqlQuery = ({ containers: containers, params
         // SPARQL keyword a = filter based on the class of a resource (example => 'a': 'pair:OrganizationType')
         // Other filters are based on a value (example => 'petr:hasAudience': 'http://localhost:3000/audiences/tout-public')
         Object.entries(filter).forEach(([predicate, object])=>{
-            if (!$33c37185da3771a9$var$reservedFilterKeys.includes(predicate)) resourceWhere.unshift($33c37185da3771a9$var$triple($33c37185da3771a9$var$variable("s1"), $33c37185da3771a9$var$namedNode((0, $761c677606459117$export$2e2bcd8739ae039)(predicate, ontologies)), $33c37185da3771a9$var$namedNode((0, $761c677606459117$export$2e2bcd8739ae039)(object, ontologies))));
+            if (!$33c37185da3771a9$var$reservedFilterKeys.includes(predicate)) resourceWhere.unshift($33c37185da3771a9$var$triple($33c37185da3771a9$var$variable('s1'), $33c37185da3771a9$var$namedNode((0, $108795c3831be99f$export$2e2bcd8739ae039)(predicate, ontologies)), $33c37185da3771a9$var$namedNode((0, $108795c3831be99f$export$2e2bcd8739ae039)(object, ontologies))));
         });
     }
     // Blank nodes
@@ -785,27 +799,7 @@ const $33c37185da3771a9$var$buildSparqlQuery = ({ containers: containers, params
         resourceWhere = resourceWhere.concat(blankNodesQuery.where);
         sparqlJsParams.template = sparqlJsParams.template.concat(blankNodesQuery.construct);
     } else resourceWhere.push(baseQuery.where);
-    sparqlJsParams.where.push({
-        type: "union",
-        patterns: [
-            containerWhere,
-            {
-                type: "graph",
-                name: $33c37185da3771a9$var$namedNode("http://semapps.org/mirror"),
-                patterns: containerWhere
-            }
-        ]
-    }, {
-        type: "union",
-        patterns: [
-            resourceWhere,
-            {
-                type: "graph",
-                name: $33c37185da3771a9$var$namedNode("http://semapps.org/mirror"),
-                patterns: resourceWhere
-            }
-        ]
-    });
+    sparqlJsParams.where.push(containerWhere, resourceWhere);
     return $33c37185da3771a9$var$generator.stringify(sparqlJsParams);
 };
 var $33c37185da3771a9$export$2e2bcd8739ae039 = $33c37185da3771a9$var$buildSparqlQuery;
@@ -813,10 +807,9 @@ var $33c37185da3771a9$export$2e2bcd8739ae039 = $33c37185da3771a9$var$buildSparql
 
 const $1e7a94d745f8597b$var$compare = (a, b)=>{
     switch(typeof a){
-        case "string":
+        case 'string':
             return a.localeCompare(b);
-        case "number":
-        case "bigint":
+        case 'number':
             return a - b;
         default:
             return 0;
@@ -825,48 +818,50 @@ 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 sparqlQueryPromises = Object.keys(containers).map((serverKey)=>new Promise((resolve, reject)=>{
+    const serversToQuery = containers.reduce((acc, cur)=>{
+        if (!acc.includes(cur.server)) acc.push(cur.server);
+        return acc;
+    }, []);
+    const sparqlQueryPromises = serversToQuery.map((serverKey)=>new Promise((resolve, reject)=>{
             const blankNodes = params.filter?.blankNodes || dataModel.list?.blankNodes;
-            // When the SPARQL request comes from the browser's URL, it comes as JSON string which must must be parsed
-            if (params.filter?.sparqlWhere && (typeof params.filter.sparqlWhere === "string" || params.filter.sparqlWhere instanceof String)) params.filter.sparqlWhere = JSON.parse(decodeURIComponent(params.filter.sparqlWhere));
             const sparqlQuery = (0, $33c37185da3771a9$export$2e2bcd8739ae039)({
-                containers: containers[serverKey],
+                containersUris: containers.filter((c)=>c.server === serverKey).map((c)=>c.uri),
                 params: params,
                 dataModel: dataModel,
                 ontologies: ontologies
             });
             httpClient(dataServers[serverKey].sparqlEndpoint, {
-                method: "POST",
+                method: 'POST',
                 body: sparqlQuery
             }).then(({ json: json })=>{
                 // If we declared the blank nodes to dereference, embed only those blank nodes
                 // This solve problems which can occur when same-type resources are embedded in other resources
                 // To increase performances, you can set explicitEmbedOnFraming to false (make sure the result is still OK)
                 const frame = blankNodes && dataModel.list?.explicitEmbedOnFraming !== false ? {
-                    "@context": jsonContext,
-                    "@type": dataModel.types,
-                    "@embed": "@never",
+                    '@context': jsonContext,
+                    '@type': dataModel.types,
+                    '@embed': '@never',
                     ...(0, $e5241bff9fc0c9d7$export$2e2bcd8739ae039)(blankNodes)
                 } : {
-                    "@context": jsonContext,
-                    "@type": dataModel.types
+                    '@context': jsonContext,
+                    '@type': dataModel.types
                 };
                 // omitGraph option force results to be in a @graph, even if we have a single result
                 return (0, ($parcel$interopDefault($bkNnK$jsonld))).frame(json, frame, {
                     omitGraph: false
                 });
             }).then((compactJson)=>{
-                if (compactJson["@id"]) {
-                    const { "@context": context, ...rest } = compactJson;
+                if (compactJson['@id']) {
+                    const { '@context': context, ...rest } = compactJson;
                     compactJson = {
-                        "@context": context,
-                        "@graph": [
+                        '@context': context,
+                        '@graph': [
                             rest
                         ]
                     };
                 }
-                resolve(compactJson["@graph"].map((resource)=>({
-                        "@context": compactJson["@context"],
+                resolve(compactJson['@graph']?.map((resource)=>({
+                        '@context': compactJson['@context'],
                         ...resource
                     })) || []);
             }).catch((e)=>reject(e));
@@ -881,13 +876,13 @@ const $1e7a94d745f8597b$var$fetchSparqlEndpoints = async (containers, resourceId
     results = [].concat(...results);
     // Add id in addition to @id, as this is what React-Admin expects
     let returnData = results.map((item)=>{
-        item.id = item.id || item["@id"];
+        item.id = item.id || item['@id'];
         return item;
     });
     // TODO sort and paginate the results in the SPARQL query to improve performances
     if (params.sort) returnData = returnData.sort((a, b)=>{
         if (a[params.sort.field] !== undefined && b[params.sort.field] !== undefined) {
-            if (params.sort.order === "ASC") return $1e7a94d745f8597b$var$compare(a[params.sort.field], b[params.sort.field]);
+            if (params.sort.order === 'ASC') return $1e7a94d745f8597b$var$compare(a[params.sort.field], b[params.sort.field]);
             return $1e7a94d745f8597b$var$compare(b[params.sort.field], a[params.sort.field]);
         }
         return 0;
@@ -902,43 +897,46 @@ var $1e7a94d745f8597b$export$2e2bcd8739ae039 = $1e7a94d745f8597b$var$fetchSparql
 
 
 
-const $e3a78b3d48a0a0fb$var$findContainersWithPaths = (paths, dataServers)=>{
-    const containers = {};
-    Object.keys(paths).forEach((serverKey)=>{
-        if (dataServers[serverKey]) {
-            containers[serverKey] = [];
-            paths[serverKey].forEach((path)=>{
-                containers[serverKey].push((0, ($parcel$interopDefault($bkNnK$urljoin)))(dataServers[serverKey].baseUrl, path));
-            });
-        } else throw new Error(`No server found with key ${serverKey}`);
+
+/**
+ * Return all containers matching the given shape tree
+ */ const $1d94774735aa9ea2$var$findContainersWithShapeTree = (shapeTreeUri, serverKeys, dataServers)=>{
+    const matchingContainers = [];
+    const parsedServerKeys = (0, $6531da3b9e8c524a$export$2e2bcd8739ae039)(serverKeys || '@all', dataServers);
+    Object.keys(dataServers).forEach((dataServerKey)=>{
+        if (parsedServerKeys.includes(dataServerKey)) dataServers[dataServerKey].containers?.forEach((container)=>{
+            if (container.shapeTreeUri === shapeTreeUri) matchingContainers.push(container);
+        });
     });
-    return containers;
+    return matchingContainers;
 };
-var $e3a78b3d48a0a0fb$export$2e2bcd8739ae039 = $e3a78b3d48a0a0fb$var$findContainersWithPaths;
+var $1d94774735aa9ea2$export$2e2bcd8739ae039 = $1d94774735aa9ea2$var$findContainersWithShapeTree;
 
 
-const $b6ed253f3374f5d4$var$getListMethod = (config)=>async (resourceId, params = {})=>{
+
+const $95cbc03f25caf72a$var$getListMethod = (config)=>async (resourceId, params)=>{
         const { dataServers: dataServers, resources: resources } = config;
         const dataModel = resources[resourceId];
         if (!dataModel) throw new Error(`Resource ${resourceId} is not mapped in resources file`);
-        let containers;
+        let containers = [];
         if (!params.filter?._servers && dataModel.list?.containers) {
             if (Array.isArray(dataModel.list?.containers)) throw new Error(`The list.containers property of ${resourceId} dataModel must be of type object ({ serverKey: [containerUri] })`);
             // If containers are set explicitly, use them
-            containers = (0, $e3a78b3d48a0a0fb$export$2e2bcd8739ae039)(dataModel.list.containers, dataServers);
-        } else // Otherwise find the container URIs on the given servers (either in the filter or the data model)
-        containers = (0, $047a107b0d203793$export$2e2bcd8739ae039)(dataModel.types, params.filter?._servers || dataModel.list?.servers, dataServers);
+            containers = (0, $37c161736d0d7276$export$2e2bcd8739ae039)(dataModel.list.containers, dataServers);
+        } else if (dataModel.shapeTreeUri) containers = (0, $1d94774735aa9ea2$export$2e2bcd8739ae039)(dataModel.shapeTreeUri, params?.filter?._servers || dataModel.list?.servers, dataServers);
+        else // Otherwise find the container URIs on the given servers (either in the filter or the data model)
+        containers = (0, $047a107b0d203793$export$2e2bcd8739ae039)((0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(dataModel.types), params?.filter?._servers || dataModel.list?.servers, dataServers);
         if (dataModel.list?.fetchContainer) return (0, $8c999cc29c8d6a6c$export$2e2bcd8739ae039)(containers, params, config);
-        return (0, $1e7a94d745f8597b$export$2e2bcd8739ae039)(containers, resourceId, params, config);
+        else return (0, $1e7a94d745f8597b$export$2e2bcd8739ae039)(containers, resourceId, params, config);
     };
-var $b6ed253f3374f5d4$export$2e2bcd8739ae039 = $b6ed253f3374f5d4$var$getListMethod;
+var $95cbc03f25caf72a$export$2e2bcd8739ae039 = $95cbc03f25caf72a$var$getListMethod;
 
 
 
 const $e296494b4f6a4f89$var$getManyMethod = (config)=>async (resourceId, params)=>{
         const { returnFailedResources: returnFailedResources } = config;
         let returnData = await Promise.all(params.ids.map((id)=>(0, $9020b8e3f4a4c1a1$export$2e2bcd8739ae039)(config)(resourceId, {
-                id: typeof id === "object" ? id["@id"] : id
+                id: typeof id === 'object' ? id['@id'] : id
             }).then(({ data: data })=>data).catch(()=>{
                 // Catch if one resource fails to load
                 // Otherwise no references will be show if only one is missing
@@ -965,7 +963,7 @@ const $e5e279a608b8e6b1$var$getManyReferenceMethod = (config)=>async (resourceId
             [params.target]: params.id
         };
         delete params.target;
-        return await (0, $b6ed253f3374f5d4$export$2e2bcd8739ae039)(config)(resourceId, params);
+        return await (0, $95cbc03f25caf72a$export$2e2bcd8739ae039)(config)(resourceId, params);
     };
 var $e5e279a608b8e6b1$export$2e2bcd8739ae039 = $e5e279a608b8e6b1$var$getManyReferenceMethod;
 
@@ -976,32 +974,32 @@ const $fda69bf2752eb49a$var$generator = new (0, $bkNnK$sparqljs.Generator)();
 const $fda69bf2752eb49a$var$patchMethod = (config)=>async (resourceId, params)=>{
         const { httpClient: httpClient } = config;
         const sparqlUpdate = {
-            type: "update",
+            type: 'update',
             prefixes: {},
             updates: []
         };
         if (params.triplesToAdd) sparqlUpdate.updates.push({
-            updateType: "insert",
+            updateType: 'insert',
             insert: [
                 {
-                    type: "bgp",
+                    type: 'bgp',
                     triples: params.triplesToAdd
                 }
             ]
         });
         if (params.triplesToRemove) sparqlUpdate.updates.push({
-            updateType: "delete",
+            updateType: 'delete',
             delete: [
                 {
-                    type: "bgp",
+                    type: 'bgp',
                     triples: params.triplesToRemove
                 }
             ]
         });
         await httpClient(`${params.id}`, {
-            method: "PATCH",
+            method: 'PATCH',
             headers: new Headers({
-                "Content-Type": "application/sparql-update"
+                'Content-Type': 'application/sparql-update'
             }),
             body: $fda69bf2752eb49a$var$generator.stringify(sparqlUpdate)
         });
@@ -1010,15 +1008,28 @@ var $fda69bf2752eb49a$export$2e2bcd8739ae039 = $fda69bf2752eb49a$var$patchMethod
 
 
 
+// Return the first server matching with the baseUrl
+const $59a07b932dae8600$var$getServerKeyFromUri = (uri, dataServers)=>{
+    if (!uri) throw Error(`No URI provided to getServerKeyFromUri`);
+    return dataServers && Object.keys(dataServers).find((key)=>{
+        if (dataServers[key].pod) // The baseUrl ends with /data so remove this part to match with the webId and webId-related URLs (/inbox, /outbox...)
+        return dataServers[key].baseUrl && uri.startsWith(dataServers[key].baseUrl.replace('/data', ''));
+        return uri.startsWith(dataServers[key].baseUrl);
+    });
+};
+var $59a07b932dae8600$export$2e2bcd8739ae039 = $59a07b932dae8600$var$getServerKeyFromUri;
+
+
 const $ceaafb56f75454f0$var$updateMethod = (config)=>async (resourceId, params)=>{
-        const { httpClient: httpClient, jsonContext: jsonContext } = config;
+        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);
+        const { updatedRecord: updatedRecord, filesToDelete: filesToDelete } = await (0, $6fcb30f76390d142$export$2e2bcd8739ae039).upload(params.data, config, serverKey);
         params.data = updatedRecord;
         await httpClient(`${params.id}`, {
-            method: "PUT",
+            method: 'PUT',
             body: JSON.stringify({
-                "@context": jsonContext,
+                '@context': jsonContext,
                 ...params.data
             })
         });
@@ -1034,152 +1045,51 @@ var $ceaafb56f75454f0$export$2e2bcd8739ae039 = $ceaafb56f75454f0$var$updateMetho
 
 
 
-const $3cfb23eead135e3f$var$fetchUserConfig = async (config)=>{
-    const { dataServers: dataServers, httpClient: httpClient } = config;
-    const token = localStorage.getItem("token");
-    const podKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("pod", dataServers);
-    const authServerKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("authServer", dataServers);
-    // If the user is logged in
-    if (token) {
-        const payload = (0, ($parcel$interopDefault($bkNnK$jwtdecode)))(token);
-        const webId = payload.webId || payload.webid; // Currently we must deal with both formats
-        let userData;
-        try {
-            const { json: json } = await httpClient(webId);
-            userData = json;
-        } catch (e) {
-            console.error(e);
-            // If the webId cannot be fetched, assume an invalid token and disconnect the user
-            localStorage.clear();
-            window.location.reload();
-            return;
-        }
-        // If we have a POD server
-        if (podKey) {
-            // Fill the config provided to the data provider
-            // We must modify the config object directly
-            config.dataServers[podKey].name = "My Pod";
-            config.dataServers[podKey].baseUrl = userData["pim:storage"] || (0, ($parcel$interopDefault($bkNnK$urljoin)))(webId, "data");
-            config.dataServers[podKey].sparqlEndpoint = userData.endpoints?.["void:sparqlEndpoint"] || (0, ($parcel$interopDefault($bkNnK$urljoin)))(webId, "sparql");
-        }
-        if (authServerKey) // Fill the config provided to the data provider
-        // We must modify the config object directly
-        config.dataServers[authServerKey].proxyUrl = userData.endpoints?.proxyUrl;
-    } else if (podKey) // If the user is not logged in, ignore the POD server
-    delete config.dataServers[podKey];
-};
-var $3cfb23eead135e3f$export$2e2bcd8739ae039 = $3cfb23eead135e3f$var$fetchUserConfig;
-
-
-const $915df908e0942746$var$defaultToArray = (value)=>!value ? undefined : Array.isArray(value) ? value : [
-        value
-    ];
-const $915df908e0942746$var$fetchVoidEndpoints = async (config)=>{
-    const fetchPromises = Object.entries(config.dataServers).filter(([key, server])=>server.pod !== true && server.void !== false).map(([key, server])=>config.httpClient(new URL("/.well-known/void", server.baseUrl).toString()).then((result)=>({
-                key: key,
-                datasets: result.json["@graph"]
-            })).catch((e)=>{
-            if (e.status === 404 || e.status === 401 || e.status === 500) return {
-                key: key,
-                error: e
-            };
-            throw e;
-        }));
-    let results = [];
-    try {
-        results = await Promise.all(fetchPromises);
-    } catch (e) {
-    // Do not throw error if no endpoint found
-    }
-    for (const result of results){
-        config.dataServers[result.key].containers = config.dataServers[result.key].containers || {};
-        config.dataServers[result.key].blankNodes = config.dataServers[result.key].blankNodes || {};
-        // Ignore unfetchable endpoints
-        if (result.datasets) for (const dataset of result.datasets){
-            const datasetServerKey = Object.keys(config.dataServers).find((key)=>dataset["void:uriSpace"] === config.dataServers[key].baseUrl);
-            // If the dataset is not part of a server mapped in the dataServers, ignore it
-            if (datasetServerKey) {
-                // If this is the local dataset, add the base information
-                if (datasetServerKey === result.key) {
-                    config.dataServers[result.key].name = config.dataServers[result.key].name || dataset["dc:title"];
-                    config.dataServers[result.key].description = config.dataServers[result.key].description || dataset["dc:description"];
-                    config.dataServers[result.key].sparqlEndpoint = config.dataServers[result.key].sparqlEndpoint || dataset["void:sparqlEndpoint"];
-                }
-                config.dataServers[result.key].containers[datasetServerKey] = config.dataServers[result.key].containers[datasetServerKey] || {};
-                for (const partition of $915df908e0942746$var$defaultToArray(dataset["void:classPartition"]))for (const type of $915df908e0942746$var$defaultToArray(partition["void:class"])){
-                    // Set containers by type
-                    const path = partition["void:uriSpace"].replace(dataset["void:uriSpace"], "/");
-                    if (config.dataServers[result.key].containers[datasetServerKey][type]) config.dataServers[result.key].containers[datasetServerKey][type].push(path);
-                    else config.dataServers[result.key].containers[datasetServerKey][type] = [
-                        path
-                    ];
-                }
-            }
-        }
-    }
-};
-var $915df908e0942746$export$2e2bcd8739ae039 = $915df908e0942746$var$fetchVoidEndpoints;
-
-
-
-
-// Return the first server matching with the baseUrl
-const $59a07b932dae8600$var$getServerKeyFromUri = (uri, dataServers)=>{
-    if (!uri) throw Error(`No URI provided to getServerKeyFromUri`);
-    return Object.keys(dataServers).find((key)=>{
-        if (dataServers[key].pod) // The baseUrl ends with /data so remove this part to match with the webId and webId-related URLs (/inbox, /outbox...)
-        return dataServers[key].baseUrl && uri.startsWith(dataServers[key].baseUrl.replace("/data", ""));
-        return uri.startsWith(dataServers[key].baseUrl);
-    });
-};
-var $59a07b932dae8600$export$2e2bcd8739ae039 = $59a07b932dae8600$var$getServerKeyFromUri;
-
-
-
 /*
  * 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 = {})=>{
-        const authServerKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("authServer", dataServers);
+        if (!url) throw new Error(`No URL provided on httpClient call`);
+        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.user?.proxyUrl && dataServers[serverKey]?.noProxy !== true;
         if (!options.headers) options.headers = new Headers();
         switch(options.method){
-            case "POST":
-            case "PATCH":
-            case "PUT":
-                if (!options.headers.has("Accept")) options.headers.set("Accept", "application/ld+json");
-                if (!options.headers.has("Content-Type")) options.headers.set("Content-Type", "application/ld+json");
+            case 'POST':
+            case 'PATCH':
+            case 'PUT':
+                if (!options.headers.has('Accept')) options.headers.set('Accept', 'application/ld+json');
+                if (!options.headers.has('Content-Type')) options.headers.set('Content-Type', 'application/ld+json');
                 break;
-            case "DELETE":
+            case 'DELETE':
                 break;
-            case "GET":
+            case 'GET':
             default:
-                if (!options.headers.has("Accept")) options.headers.set("Accept", "application/ld+json");
+                if (!options.headers.has('Accept')) options.headers.set('Accept', 'application/ld+json');
                 break;
         }
         if (useProxy) {
             const formData = new FormData();
-            formData.append("id", url);
-            formData.append("method", options.method || "GET");
-            formData.append("headers", JSON.stringify(Object.fromEntries(options.headers.entries())));
+            formData.append('id', url);
+            formData.append('method', options.method || 'GET');
+            formData.append('headers', JSON.stringify(Object.fromEntries(options.headers.entries())));
             if (options.body) {
-                if (options.body instanceof File) formData.append("body", options.body, options.body.name);
-                else formData.append("body", options.body);
+                if (options.body instanceof File) formData.append('body', options.body, options.body.name);
+                else formData.append('body', options.body);
             }
             // Post to proxy endpoint with multipart/form-data format
-            return (0, $bkNnK$reactadmin.fetchUtils).fetchJson(dataServers[authServerKey].proxyUrl, {
-                method: "POST",
+            return (0, $bkNnK$reactadmin.fetchUtils).fetchJson(dataServers.user.proxyUrl, {
+                method: 'POST',
                 headers: new Headers({
-                    Authorization: `Bearer ${localStorage.getItem("token")}`
+                    Authorization: `Bearer ${localStorage.getItem('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}`);
+            const token = localStorage.getItem('token');
+            if (token) options.headers.set('Authorization', `Bearer ${token}`);
         }
         return (0, $bkNnK$reactadmin.fetchUtils).fetchJson(url, options);
     };
@@ -1187,54 +1097,171 @@ var $341dff85fe619d85$export$2e2bcd8739ae039 = $341dff85fe619d85$var$httpClient;
 
 
 
-/** @type {(config: Configuration) => SemanticDataProvider} */ const $7f6a16d0025dc83a$var$dataProvider = (config)=>{
-    // TODO verify all data provider config + data models
-    if (!(0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("default", config.dataServers)) throw new Error("You must define a default server in your dataServers config");
-    if (!config.jsonContext) config.jsonContext = Object.fromEntries(config.ontologies.map((o)=>[
-            o.prefix,
-            o.url
-        ]));
-    if (!config.returnFailedResources) config.returnFailedResources = false;
-    // Configure httpClient with data servers (this is needed for proxy calls)
-    config.httpClient = (0, $341dff85fe619d85$export$2e2bcd8739ae039)(config.dataServers);
-    // Keep in memory for refresh
-    const originalConfig = {
+
+
+
+
+const $9ab033d1ec46b5da$var$isURL = (value)=>(typeof value === 'string' || value instanceof String) && value.startsWith('http');
+const $9ab033d1ec46b5da$var$expandTypes = async (types, context)=>{
+    // If types are already full URIs, return them immediately
+    if (types.every((type)=>$9ab033d1ec46b5da$var$isURL(type))) return types;
+    const result = await (0, ($parcel$interopDefault($bkNnK$jsonld))).expand({
+        '@context': context,
+        '@type': types
+    });
+    const expandedTypes = (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(result[0]['@type']);
+    if (!expandedTypes.every((type)=>$9ab033d1ec46b5da$var$isURL(type))) throw new Error(`
+      Could not expand all types (${expandedTypes.join(', ')}).
+      Is an ontology missing or not registered yet on the local context ?
+    `);
+    return expandedTypes;
+};
+var $9ab033d1ec46b5da$export$2e2bcd8739ae039 = $9ab033d1ec46b5da$var$expandTypes;
+
+
+
+
+const $058bb6151d120fba$var$getTypesFromShapeTree = async (shapeTreeUri)=>{
+    let { json: shapeTree } = await (0, $bkNnK$reactadmin.fetchUtils).fetchJson(shapeTreeUri, {
+        headers: new Headers({
+            Accept: 'application/ld+json'
+        })
+    });
+    shapeTree = await (0, ($parcel$interopDefault($bkNnK$jsonld))).compact(shapeTree, {
+        st: 'http://www.w3.org/ns/shapetrees#',
+        skos: 'http://www.w3.org/2004/02/skos/core#',
+        expectsType: {
+            '@id': 'st:expectsType',
+            '@type': '@id'
+        },
+        shape: {
+            '@id': 'st:shape',
+            '@type': '@id'
+        },
+        describesInstance: {
+            '@id': 'st:describesInstance',
+            '@type': '@id'
+        },
+        label: {
+            '@id': 'skos:prefLabel',
+            '@container': '@language'
+        }
+    });
+    if (shapeTree.shape) {
+        const { json: shape } = await (0, $bkNnK$reactadmin.fetchUtils).fetchJson(shapeTree.shape, {
+            headers: new Headers({
+                Accept: 'application/ld+json'
+            })
+        });
+        return shape?.[0]?.['http://www.w3.org/ns/shacl#targetClass']?.map((node)=>node?.['@id']) || [];
+    } else return [];
+};
+var $058bb6151d120fba$export$2e2bcd8739ae039 = $058bb6151d120fba$var$getTypesFromShapeTree;
+
+
+const $5e24772571dd1677$var$normalizeConfig = async (config)=>{
+    const newConfig = {
         ...config
     };
-    let fetchUserConfigPromise = (0, $3cfb23eead135e3f$export$2e2bcd8739ae039)(config);
-    let fetchVoidEndpointsPromise = (0, $915df908e0942746$export$2e2bcd8739ae039)(config);
-    const waitForConfig = (method)=>async (...arg)=>{
-            await fetchUserConfigPromise;
-            await fetchVoidEndpointsPromise; // Return immediately if promise is fulfilled
-            return await method(...arg);
+    // Add server and uri key to servers' containers
+    for (const serverKey of Object.keys(newConfig.dataServers))if (newConfig.dataServers[serverKey].containers) newConfig.dataServers[serverKey].containers = await Promise.all(newConfig.dataServers[serverKey].containers?.map(async (container)=>{
+        return {
+            ...container,
+            types: container.types && await (0, $9ab033d1ec46b5da$export$2e2bcd8739ae039)(container.types, config.jsonContext),
+            server: serverKey,
+            uri: (0, ($parcel$interopDefault($bkNnK$urljoin)))(config.dataServers[serverKey].baseUrl, container.path)
+        };
+    }));
+    // Expand types in data models
+    for (const resourceId of Object.keys(newConfig.resources)){
+        if (!newConfig.resources[resourceId].types && newConfig.resources[resourceId].shapeTreeUri) newConfig.resources[resourceId].types = await (0, $058bb6151d120fba$export$2e2bcd8739ae039)(newConfig.resources[resourceId].shapeTreeUri);
+        newConfig.resources[resourceId].types = await (0, $9ab033d1ec46b5da$export$2e2bcd8739ae039)((0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(newConfig.resources[resourceId].types), config.jsonContext);
+    }
+    return newConfig;
+};
+var $5e24772571dd1677$export$2e2bcd8739ae039 = $5e24772571dd1677$var$normalizeConfig;
+
+
+
+
+const $fcf4eee3b18e8350$var$isURL = (value)=>(typeof value === 'string' || value instanceof String) && value.startsWith('http');
+const $fcf4eee3b18e8350$var$getOntologiesFromContextJson = (contextJson)=>{
+    const ontologies = {};
+    for (const [key, value] of Object.entries(contextJson))if ($fcf4eee3b18e8350$var$isURL(value)) ontologies[key] = value;
+    return ontologies;
+};
+const $fcf4eee3b18e8350$var$getOntologiesFromContextUrl = async (contextUrl)=>{
+    const { json: json } = await (0, $bkNnK$reactadmin.fetchUtils).fetchJson(contextUrl, {
+        headers: new Headers({
+            Accept: 'application/ld+json'
+        })
+    });
+    return $fcf4eee3b18e8350$var$getOntologiesFromContextJson(json['@context']);
+};
+const $fcf4eee3b18e8350$var$getOntologiesFromContext = async (context)=>{
+    let ontologies = {};
+    if (Array.isArray(context)) for (const contextUrl of context)ontologies = {
+        ...ontologies,
+        ...await $fcf4eee3b18e8350$var$getOntologiesFromContextUrl(contextUrl)
+    };
+    else if (typeof context === 'string') ontologies = await $fcf4eee3b18e8350$var$getOntologiesFromContextUrl(context);
+    else ontologies = $fcf4eee3b18e8350$var$getOntologiesFromContextJson(context);
+    return ontologies;
+};
+var $fcf4eee3b18e8350$export$2e2bcd8739ae039 = $fcf4eee3b18e8350$var$getOntologiesFromContext;
+
+
+/** @type {(originalConfig: Configuration) => SemanticDataProvider} */ const $7f6a16d0025dc83a$var$dataProvider = (originalConfig)=>{
+    // Keep in memory for refresh
+    let config = {
+        ...originalConfig
+    };
+    const prepareConfig = async ()=>{
+        config.dataServers ??= {};
+        // Configure httpClient with initial data servers, so that plugins may use it
+        config.httpClient = (0, $341dff85fe619d85$export$2e2bcd8739ae039)(config.dataServers);
+        for (const plugin of config.plugins)if (plugin.transformConfig) config = await plugin.transformConfig(config);
+        // Configure again httpClient with possibly updated data servers
+        config.httpClient = (0, $341dff85fe619d85$export$2e2bcd8739ae039)(config.dataServers);
+        if (!config.ontologies && config.jsonContext) config.ontologies = await (0, $fcf4eee3b18e8350$export$2e2bcd8739ae039)(config.jsonContext);
+        else if (!config.jsonContext && config.ontologies) config.jsonContext = config.ontologies;
+        else if (!config.jsonContext && !config.ontologies) throw new Error(`Either the JSON context or the ontologies must be set`);
+        if (!config.returnFailedResources) config.returnFailedResources = false;
+        config = await (0, $5e24772571dd1677$export$2e2bcd8739ae039)(config);
+        console.log('Config after plugins', config);
+    };
+    // Immediately call the preload plugins
+    const prepareConfigPromise = prepareConfig();
+    const waitForPrepareConfig = (method)=>async (...arg)=>{
+            await prepareConfigPromise; // Return immediately if plugins have already been loaded
+            return method(config)(...arg);
         };
     return {
-        getList: waitForConfig((0, $b6ed253f3374f5d4$export$2e2bcd8739ae039)(config)),
-        getMany: waitForConfig((0, $e296494b4f6a4f89$export$2e2bcd8739ae039)(config)),
-        getManyReference: waitForConfig((0, $e5e279a608b8e6b1$export$2e2bcd8739ae039)(config)),
-        getOne: waitForConfig((0, $9020b8e3f4a4c1a1$export$2e2bcd8739ae039)(config)),
-        create: waitForConfig((0, $907cbc087f6529e2$export$2e2bcd8739ae039)(config)),
-        update: waitForConfig((0, $ceaafb56f75454f0$export$2e2bcd8739ae039)(config)),
+        getList: waitForPrepareConfig((0, $95cbc03f25caf72a$export$2e2bcd8739ae039)),
+        getMany: waitForPrepareConfig((0, $e296494b4f6a4f89$export$2e2bcd8739ae039)),
+        getManyReference: waitForPrepareConfig((0, $e5e279a608b8e6b1$export$2e2bcd8739ae039)),
+        getOne: waitForPrepareConfig((0, $9020b8e3f4a4c1a1$export$2e2bcd8739ae039)),
+        create: waitForPrepareConfig((0, $907cbc087f6529e2$export$2e2bcd8739ae039)),
+        update: waitForPrepareConfig((0, $ceaafb56f75454f0$export$2e2bcd8739ae039)),
         updateMany: ()=>{
-            throw new Error("updateMany is not implemented yet");
+            throw new Error('updateMany is not implemented yet');
         },
-        delete: waitForConfig((0, $566b5adde94810fa$export$2e2bcd8739ae039)(config)),
-        deleteMany: waitForConfig((0, $f170294dd29d8bf8$export$2e2bcd8739ae039)(config)),
+        delete: waitForPrepareConfig((0, $566b5adde94810fa$export$2e2bcd8739ae039)),
+        deleteMany: waitForPrepareConfig((0, $f170294dd29d8bf8$export$2e2bcd8739ae039)),
         // Custom methods
-        patch: waitForConfig((0, $fda69bf2752eb49a$export$2e2bcd8739ae039)(config)),
-        getDataModels: waitForConfig((0, $241c41c6f6021c7a$export$2e2bcd8739ae039)(config)),
-        getDataServers: waitForConfig((0, $b16131432127b07b$export$2e2bcd8739ae039)(config)),
-        getLocalDataServers: (0, $b16131432127b07b$export$2e2bcd8739ae039)(config),
-        fetch: waitForConfig(config.httpClient),
-        uploadFile: waitForConfig((rawFile)=>(0, $6fcb30f76390d142$export$a5575dbeeffdad98)(rawFile, config)),
+        patch: waitForPrepareConfig((0, $fda69bf2752eb49a$export$2e2bcd8739ae039)),
+        getDataModels: waitForPrepareConfig((0, $241c41c6f6021c7a$export$2e2bcd8739ae039)),
+        getDataServers: waitForPrepareConfig((0, $b16131432127b07b$export$2e2bcd8739ae039)),
+        getLocalDataServers: (0, $b16131432127b07b$export$2e2bcd8739ae039)(originalConfig),
+        fetch: waitForPrepareConfig((c)=>(0, $341dff85fe619d85$export$2e2bcd8739ae039)(c.dataServers)),
+        uploadFile: waitForPrepareConfig((c)=>(rawFile)=>(0, $6fcb30f76390d142$export$a5575dbeeffdad98)(rawFile, c)),
+        expandTypes: waitForPrepareConfig((c)=>(types)=>(0, $9ab033d1ec46b5da$export$2e2bcd8739ae039)(types, c.jsonContext)),
+        getConfig: waitForPrepareConfig((c)=>()=>c),
         refreshConfig: async ()=>{
             config = {
                 ...originalConfig
             };
-            fetchUserConfigPromise = (0, $3cfb23eead135e3f$export$2e2bcd8739ae039)(config);
-            fetchVoidEndpointsPromise = (0, $915df908e0942746$export$2e2bcd8739ae039)(config);
-            await fetchUserConfigPromise;
-            await fetchVoidEndpointsPromise;
+            await prepareConfig();
             return config;
         }
     };
@@ -1245,95 +1272,403 @@ var $7f6a16d0025dc83a$export$2e2bcd8739ae039 = $7f6a16d0025dc83a$var$dataProvide
 
 
 
+const $8c4c0f0b55649ce6$var$getPrefixFromUri = (uri, ontologies)=>{
+    for (const [prefix, namespace] of Object.entries(ontologies)){
+        if (uri.startsWith(namespace)) return uri.replace(namespace, `${prefix}:`);
+    }
+    return uri;
+};
+var $8c4c0f0b55649ce6$export$2e2bcd8739ae039 = $8c4c0f0b55649ce6$var$getPrefixFromUri;
 
-const $85e9a897c6d7c14a$var$compute = (externalLinks, record)=>typeof externalLinks === "function" ? externalLinks(record) : externalLinks;
-const $85e9a897c6d7c14a$var$isURL = (url)=>typeof url === "string" && url.startsWith("http");
-const $85e9a897c6d7c14a$var$useGetExternalLink = (componentExternalLinks)=>{
-    // Since the externalLinks config is defined only locally, we don't need to wait for VOID endpoints fetching
-    const dataProvider = (0, $bkNnK$react.useContext)((0, $bkNnK$reactadmin.DataProviderContext));
-    const dataServers = dataProvider.getLocalDataServers();
-    const serversExternalLinks = (0, $bkNnK$react.useMemo)(()=>{
-        if (dataServers) return Object.fromEntries(Object.values(dataServers).map((server)=>{
-            // If externalLinks is not defined in the data server, use external links for non-default servers
-            const externalLinks = server.externalLinks !== undefined ? server.externalLinks : !server.default;
-            return [
-                server.baseUrl,
-                externalLinks
-            ];
-        }));
-    }, [
-        dataServers
-    ]);
-    return (0, $bkNnK$react.useCallback)((record)=>{
-        const computedComponentExternalLinks = $85e9a897c6d7c14a$var$compute(componentExternalLinks, record);
-        // If the component explicitly asks not to display as external links, use an internal link
-        if (computedComponentExternalLinks === false) return false;
-        if (!record?.id) return false;
-        const serverBaseUrl = Object.keys(serversExternalLinks).find((baseUrl)=>record?.id.startsWith(baseUrl));
-        // If no matching data servers could be found, assume we have an internal link
-        if (!serverBaseUrl) return false;
-        const computedServerExternalLinks = $85e9a897c6d7c14a$var$compute(serversExternalLinks[serverBaseUrl], record);
-        // If the data server explicitly asks not to display as external links, use an internal link
-        if (computedServerExternalLinks === false) return false;
-        if ($85e9a897c6d7c14a$var$isURL(computedComponentExternalLinks)) return computedComponentExternalLinks;
-        if ($85e9a897c6d7c14a$var$isURL(computedServerExternalLinks)) return computedServerExternalLinks;
-        return record.id;
-    }, [
-        serversExternalLinks,
-        componentExternalLinks
-    ]);
+
+
+
+const $89358cee13a17a31$var$configureUserStorage = ()=>({
+        transformConfig: async (config)=>{
+            const token = localStorage.getItem('token');
+            // If the user is logged in
+            if (token) {
+                const payload = (0, ($parcel$interopDefault($bkNnK$jwtdecode)))(token);
+                const webId = payload.webId || payload.webid; // Currently we must deal with both formats
+                const { json: user } = await config.httpClient(webId);
+                if (user) {
+                    const newConfig = {
+                        ...config
+                    };
+                    newConfig.dataServers.user = {
+                        pod: true,
+                        default: true,
+                        authServer: true,
+                        baseUrl: user['pim:storage'] || (0, ($parcel$interopDefault($bkNnK$urljoin)))(webId, 'data'),
+                        sparqlEndpoint: user.endpoints?.['void:sparqlEndpoint'] || (0, ($parcel$interopDefault($bkNnK$urljoin)))(webId, 'sparql'),
+                        proxyUrl: user.endpoints?.proxyUrl,
+                        containers: []
+                    };
+                    if (!newConfig.jsonContext) newConfig.jsonContext = [
+                        'https://www.w3.org/ns/activitystreams',
+                        (0, ($parcel$interopDefault($bkNnK$urljoin)))(new URL(webId).origin, '/.well-known/context.jsonld')
+                    ];
+                    return newConfig;
+                }
+            }
+            // Nothing to change
+            return config;
+        }
+    });
+var $89358cee13a17a31$export$2e2bcd8739ae039 = $89358cee13a17a31$var$configureUserStorage;
+
+
+
+
+
+
+
+const $37dc42f6e1c3b4af$var$getContainerFromDataRegistration = async (dataRegistrationUri, config)=>{
+    const { json: dataRegistration } = await config.httpClient(dataRegistrationUri, {
+        headers: new Headers({
+            Accept: 'application/ld+json',
+            Prefer: 'return=representation; include="http://www.w3.org/ns/ldp#PreferMinimalContainer"'
+        })
+    });
+    const shapeTreeUri = dataRegistration['interop:registeredShapeTree'];
+    let { json: shapeTree } = await (0, $bkNnK$reactadmin.fetchUtils).fetchJson(shapeTreeUri, {
+        headers: new Headers({
+            Accept: 'application/ld+json'
+        })
+    });
+    shapeTree = await (0, ($parcel$interopDefault($bkNnK$jsonld))).compact(shapeTree, {
+        st: 'http://www.w3.org/ns/shapetrees#',
+        skos: 'http://www.w3.org/2004/02/skos/core#',
+        expectsType: {
+            '@id': 'st:expectsType',
+            '@type': '@id'
+        },
+        shape: {
+            '@id': 'st:shape',
+            '@type': '@id'
+        },
+        describesInstance: {
+            '@id': 'st:describesInstance',
+            '@type': '@id'
+        },
+        label: {
+            '@id': 'skos:prefLabel',
+            '@container': '@language'
+        }
+    });
+    const { baseUrl: baseUrl } = config.dataServers.user;
+    const containerPath = dataRegistration.id.replace(baseUrl, '');
+    const container = {
+        path: containerPath,
+        shapeTreeUri: shapeTreeUri,
+        label: shapeTree.label,
+        labelPredicate: shapeTree.describesInstance,
+        binaryResources: shapeTree.expectsType === 'st:NonRDFResource'
+    };
+    if (shapeTree.shape) {
+        const { json: shape } = await (0, $bkNnK$reactadmin.fetchUtils).fetchJson(shapeTree.shape, {
+            headers: new Headers({
+                Accept: 'application/ld+json'
+            })
+        });
+        container.types = shape?.[0]?.['http://www.w3.org/ns/shacl#targetClass']?.map((node)=>node?.['@id']);
+    }
+    return container;
 };
-var $85e9a897c6d7c14a$export$2e2bcd8739ae039 = $85e9a897c6d7c14a$var$useGetExternalLink;
+var $37dc42f6e1c3b4af$export$2e2bcd8739ae039 = $37dc42f6e1c3b4af$var$getContainerFromDataRegistration;
 
 
+/**
+ * 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 = ()=>({
+        transformConfig: async (config)=>{
+            const token = localStorage.getItem('token');
+            // If the user is logged in
+            if (token) {
+                const payload = (0, ($parcel$interopDefault($bkNnK$jwtdecode)))(token);
+                const webId = payload.webId || payload.webid; // Currently we must deal with both formats
+                const { json: user } = await config.httpClient(webId);
+                const authAgentUri = user['interop:hasAuthorizationAgent'];
+                if (authAgentUri) {
+                    // Find if an application registration is linked to this user
+                    // See https://solid.github.io/data-interoperability-panel/specification/#agent-registration-discovery
+                    const { headers: headers } = await config.httpClient(authAgentUri);
+                    if (headers.has('Link')) {
+                        const linkHeader = (0, ($parcel$interopDefault($bkNnK$httplinkheader))).parse(headers.get('Link'));
+                        const registeredAgentLinkHeader = linkHeader.rel('http://www.w3.org/ns/solid/interop#registeredAgent');
+                        if (registeredAgentLinkHeader.length > 0) {
+                            const appRegistrationUri = registeredAgentLinkHeader[0].anchor;
+                            const { json: appRegistration } = await config.httpClient(appRegistrationUri);
+                            const newConfig = {
+                                ...config
+                            };
+                            // Load data 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);
+                                }));
+                            }));
+                            newConfig.dataServers.user.containers = results.flat();
+                            return newConfig;
+                        }
+                    }
+                }
+            }
+            return config;
+        }
+    });
+var $c512de108ef5d674$export$2e2bcd8739ae039 = $c512de108ef5d674$var$fetchAppRegistration;
+
+
+
+
+const $cd772adda3024172$var$fetchDataRegistry = ()=>({
+        transformConfig: async (config)=>{
+            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
+                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']);
+                if (dataRegistry['interop:hasDataRegistration']) {
+                    const results = await Promise.all(dataRegistry['interop:hasDataRegistration'].map((dataRegistrationUri)=>{
+                        return (0, $37dc42f6e1c3b4af$export$2e2bcd8739ae039)(dataRegistrationUri, config);
+                    }));
+                    const newConfig = {
+                        ...config
+                    };
+                    newConfig.dataServers.user.containers?.push(...results.flat());
+                    return newConfig;
+                }
+            }
+            // Nothing to change
+            return config;
+        }
+    });
+var $cd772adda3024172$export$2e2bcd8739ae039 = $cd772adda3024172$var$fetchDataRegistry;
 
 
 
-const $63a32f1a35c6f80e$var$useDataModel = (resourceId)=>{
-    // Get the raw data provider, since useDataProvider returns a wrapper
-    const dataProvider = (0, $bkNnK$react.useContext)((0, $bkNnK$reactadmin.DataProviderContext));
-    const [dataModel, setDataModel] = (0, $bkNnK$react.useState)(undefined); // TODO: Type this object
+
+
+
+const $69d4da9beaa62ac6$var$fetchTypeIndexes = ()=>({
+        transformConfig: async (config)=>{
+            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
+                const { json: user } = await config.httpClient(webId);
+                const typeRegistrations = {
+                    public: [],
+                    private: []
+                };
+                if (user['solid:publicTypeIndex']) {
+                    const { json: publicTypeIndex } = await config.httpClient(user['solid:publicTypeIndex']);
+                    if (publicTypeIndex) typeRegistrations.public = (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(publicTypeIndex['solid:hasTypeRegistration']);
+                }
+                if (user['pim:preferencesFile']) {
+                    const { json: preferencesFile } = await config.httpClient(user['pim:preferencesFile']);
+                    if (preferencesFile?.['solid:privateTypeIndex']) {
+                        const { json: privateTypeIndex } = await config.httpClient(preferencesFile['solid:privateTypeIndex']);
+                        typeRegistrations.private = (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(privateTypeIndex['solid:hasTypeRegistration']);
+                    }
+                }
+                if (typeRegistrations.public.length > 0 || typeRegistrations.private.length > 0) {
+                    const newConfig = {
+                        ...config
+                    };
+                    for (const mode of Object.keys(typeRegistrations))for (const typeRegistration of typeRegistrations[mode]){
+                        const types = (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(typeRegistration['solid:forClass']);
+                        const container = {
+                            label: {
+                                en: (0, $bkNnK$changecase.capitalCase)(types[0].split(':')[1], {
+                                    separateNumbers: true
+                                })
+                            },
+                            path: typeRegistration['solid:instanceContainer'].replace(newConfig.dataServers.user.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);
+                        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] = {
+                            ...container,
+                            ...newConfig.dataServers.user.containers[containerIndex]
+                        };
+                        else newConfig.dataServers.user.containers.push(container);
+                    }
+                    return newConfig;
+                }
+            }
+            return config;
+        }
+    });
+var $69d4da9beaa62ac6$export$2e2bcd8739ae039 = $69d4da9beaa62ac6$var$fetchTypeIndexes;
+
+
+
+
+const $1395e306228d41f2$var$fetchVoidEndpoints = ()=>({
+        transformConfig: async (config)=>{
+            let results = [];
+            try {
+                results = await Promise.all(Object.entries(config.dataServers).filter(([_, server])=>server.pod !== true && server.void !== false).map(async ([key, server])=>config.httpClient(new URL('/.well-known/void', server.baseUrl).toString()).then((result)=>({
+                            key: key,
+                            context: result.json?.['@context'],
+                            datasets: result.json?.['@graph']
+                        })).catch((e)=>{
+                        if (e.status === 404 || e.status === 401 || e.status === 500) return {
+                            key: key,
+                            error: e.message
+                        };
+                        throw e;
+                    })));
+            } catch (e) {
+            // Do not throw error if no endpoint found
+            }
+            results = results.filter((result)=>result.datasets);
+            if (results.length > 0) {
+                const newConfig = {
+                    ...config
+                };
+                for (const result of results){
+                    // Ignore unfetchable endpoints
+                    if (result.datasets) for (const dataset of result.datasets){
+                        newConfig.dataServers[result.key].name ??= dataset['dc:title'];
+                        newConfig.dataServers[result.key].description ??= dataset['dc:description'];
+                        newConfig.dataServers[result.key].sparqlEndpoint ??= dataset['void:sparqlEndpoint'];
+                        newConfig.dataServers[result.key].containers ??= [];
+                        for (const partition of (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(dataset['void:classPartition']))for (const type of (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(partition['void:class'])){
+                            const path = partition['void:uriSpace'].replace(dataset['void:uriSpace'], '/');
+                            const expandedTypes = await (0, $9ab033d1ec46b5da$export$2e2bcd8739ae039)([
+                                type
+                            ], result.context);
+                            const containerIndex = newConfig.dataServers[result.key].containers.findIndex((c)=>c.types?.some((t)=>expandedTypes.includes(t)));
+                            if (containerIndex && containerIndex !== -1) // If a container with this type already exist, overwrite path and types
+                            newConfig.dataServers[result.key].containers[containerIndex] = {
+                                ...newConfig.dataServers[result.key].containers[containerIndex],
+                                path: path,
+                                types: expandedTypes
+                            };
+                            else newConfig.dataServers[result.key].containers.push({
+                                path: path,
+                                types: expandedTypes
+                            });
+                        }
+                    }
+                }
+                return newConfig;
+            } else return config;
+        }
+    });
+var $1395e306228d41f2$export$2e2bcd8739ae039 = $1395e306228d41f2$var$fetchVoidEndpoints;
+
+
+
+
+
+const $9def35f4441a9bb2$var$useDataProviderConfig = ()=>{
+    const dataProvider = (0, $bkNnK$reactadmin.useDataProvider)();
+    const [config, setConfig] = (0, $bkNnK$react.useState)();
+    const [isLoading, setIsLoading] = (0, $bkNnK$react.useState)(false);
     (0, $bkNnK$react.useEffect)(()=>{
-        dataProvider.getDataModels().then((results)=>setDataModel(results[resourceId]));
+        if (!isLoading && !config) {
+            setIsLoading(true);
+            dataProvider.getConfig().then((c)=>{
+                setConfig(c);
+                setIsLoading(false);
+            });
+        }
     }, [
         dataProvider,
-        resourceId,
-        setDataModel
+        setConfig,
+        config,
+        setIsLoading,
+        isLoading
     ]);
-    return dataModel;
+    return config;
 };
-var $63a32f1a35c6f80e$export$2e2bcd8739ae039 = $63a32f1a35c6f80e$var$useDataModel;
+var $9def35f4441a9bb2$export$2e2bcd8739ae039 = $9def35f4441a9bb2$var$useDataProviderConfig;
 
 
 
+const $013953e307d438b1$var$compactPredicate = async (predicate, context)=>{
+    const result = await (0, ($parcel$interopDefault($bkNnK$jsonld))).compact({
+        [predicate]: ''
+    }, context);
+    return Object.keys(result).find((key)=>key !== '@context');
+};
+var $013953e307d438b1$export$2e2bcd8739ae039 = $013953e307d438b1$var$compactPredicate;
 
-const $c9933a88e2acc4da$var$useDataServers = ()=>{
-    const dataProvider = (0, $bkNnK$reactadmin.useDataProvider)();
-    const [dataServers, setDataServers] = (0, $bkNnK$react.useState)();
+
+const $9d33c8835e67bede$var$useCompactPredicate = (predicate, context)=>{
+    const config = (0, $9def35f4441a9bb2$export$2e2bcd8739ae039)();
+    const [result, setResult] = (0, $bkNnK$react.useState)();
     (0, $bkNnK$react.useEffect)(()=>{
-        dataProvider.getDataServers().then((results)=>{
-            setDataServers(results);
+        if (config && predicate) (0, $013953e307d438b1$export$2e2bcd8739ae039)(predicate, context || config.jsonContext).then((r)=>{
+            setResult(r);
         });
     }, [
-        dataProvider,
-        setDataServers
+        predicate,
+        setResult,
+        config,
+        context
     ]);
-    return dataServers;
+    return result;
+};
+var $9d33c8835e67bede$export$2e2bcd8739ae039 = $9d33c8835e67bede$var$useCompactPredicate;
+
+
+
+
+const $20621bc841a5205a$var$useDataModels = ()=>{
+    const config = (0, $9def35f4441a9bb2$export$2e2bcd8739ae039)();
+    return config?.resources;
+};
+var $20621bc841a5205a$export$2e2bcd8739ae039 = $20621bc841a5205a$var$useDataModels;
+
+
+
+const $c9933a88e2acc4da$var$useDataServers = ()=>{
+    const config = (0, $9def35f4441a9bb2$export$2e2bcd8739ae039)();
+    return config?.dataServers;
 };
 var $c9933a88e2acc4da$export$2e2bcd8739ae039 = $c9933a88e2acc4da$var$useDataServers;
 
 
 
-const $3158e0dc13ffffaa$var$useContainers = (resourceId, serverKeys = "@all")=>{
-    const dataModel = (0, $63a32f1a35c6f80e$export$2e2bcd8739ae039)(resourceId);
+
+
+const $3158e0dc13ffffaa$var$useContainers = (resourceId, serverKeys)=>{
+    const dataModels = (0, $20621bc841a5205a$export$2e2bcd8739ae039)();
     const dataServers = (0, $c9933a88e2acc4da$export$2e2bcd8739ae039)();
-    const [containers, setContainers] = (0, $bkNnK$react.useState)();
+    const [containers, setContainers] = (0, $bkNnK$react.useState)([]);
+    // Warning: if serverKeys change, the containers list will not be updated (otherwise we have an infinite re-render loop)
     (0, $bkNnK$react.useEffect)(()=>{
-        if (dataModel && dataServers) setContainers((0, $047a107b0d203793$export$2e2bcd8739ae039)(dataModel.types, serverKeys, dataServers));
+        if (dataServers && dataModels) {
+            if (resourceId) {
+                const dataModel = dataModels[resourceId];
+                setContainers((0, $047a107b0d203793$export$2e2bcd8739ae039)((0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(dataModel.types), serverKeys, dataServers));
+            } else {
+                const parsedServerKeys = (0, $6531da3b9e8c524a$export$2e2bcd8739ae039)(serverKeys || '@all', dataServers);
+                setContainers(parsedServerKeys.map((serverKey)=>dataServers[serverKey].containers).flat());
+            }
+        }
     }, [
-        dataModel,
+        dataModels,
         dataServers,
-        serverKeys
+        setContainers,
+        resourceId
     ]);
     return containers;
 };
@@ -1345,96 +1680,164 @@ var $3158e0dc13ffffaa$export$2e2bcd8739ae039 = $3158e0dc13ffffaa$var$useContaine
 
 
 
-const $ff3623bf1421ebcc$var$findCreateContainerWithTypes = (types, createServerKey, dataServers)=>{
-    const containers = [];
-    Object.keys(dataServers[createServerKey].containers?.[createServerKey] || {}).forEach((type)=>{
-        if (types.includes(type)) dataServers[createServerKey].containers[createServerKey][type].forEach((path)=>{
-            const containerUri = (0, ($parcel$interopDefault($bkNnK$urljoin)))(dataServers[createServerKey].baseUrl, path);
-            if (!containers.includes(containerUri)) containers.push(containerUri);
+const $21fb109d85e9c16c$var$useContainersByTypes = (types)=>{
+    const dataServers = (0, $c9933a88e2acc4da$export$2e2bcd8739ae039)();
+    const dataProvider = (0, $bkNnK$reactadmin.useDataProvider)();
+    const [containers, setContainers] = (0, $bkNnK$react.useState)([]);
+    (0, $bkNnK$react.useEffect)(()=>{
+        if (dataServers && types) dataProvider.expandTypes((0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(types)).then((expandedTypes)=>{
+            setContainers((0, $047a107b0d203793$export$2e2bcd8739ae039)(expandedTypes, '@all', dataServers));
+        }).catch(()=>{
+        // Ignore errors
         });
-    });
-    if (containers.length === 0) throw new Error(`No container found matching with types ${JSON.stringify(types)}. You can set explicitely the create.container property of the resource.`);
-    else if (containers.length > 1) throw new Error(`More than one container found matching with types ${JSON.stringify(types)}. You must set the create.server or create.container property for the resource.`);
-    return containers[0];
+    }, [
+        dataServers,
+        dataProvider,
+        setContainers,
+        types
+    ]);
+    return containers;
 };
-var $ff3623bf1421ebcc$export$2e2bcd8739ae039 = $ff3623bf1421ebcc$var$findCreateContainerWithTypes;
+var $21fb109d85e9c16c$export$2e2bcd8739ae039 = $21fb109d85e9c16c$var$useContainersByTypes;
+
 
 
 
-/** @deprecated Use "useCreateContainerUri" instead */ const $99ed32cbdb76cb50$var$useCreateContainer = (resourceId)=>{
-    const dataModel = (0, $63a32f1a35c6f80e$export$2e2bcd8739ae039)(resourceId);
+const $d3746ce11bc56f3b$var$useContainerByUri = (containerUri)=>{
     const dataServers = (0, $c9933a88e2acc4da$export$2e2bcd8739ae039)();
-    const [createContainer, setCreateContainer] = (0, $bkNnK$react.useState)();
+    const [container, setContainer] = (0, $bkNnK$react.useState)();
     (0, $bkNnK$react.useEffect)(()=>{
-        if (dataModel && dataServers) {
-            if (dataModel.create?.container) {
-                const [serverKey, path] = Object.entries(dataModel.create.container)[0];
-                if (!serverKey || !dataServers[serverKey]) throw new Error(`Wrong key for the dataModel.create.container config of resource ${resourceId}`);
-                setCreateContainer((0, ($parcel$interopDefault($bkNnK$urljoin)))(dataServers[serverKey].baseUrl, path));
-            } else if (dataModel.create?.server) setCreateContainer((0, $ff3623bf1421ebcc$export$2e2bcd8739ae039)(dataModel.types, dataModel.create?.server, dataServers));
-            else {
-                const defaultServerKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("default", dataServers);
-                setCreateContainer((0, $ff3623bf1421ebcc$export$2e2bcd8739ae039)(dataModel.types, defaultServerKey, dataServers));
-            }
-        }
+        if (dataServers && containerUri) Object.keys(dataServers).forEach((serverKey)=>{
+            dataServers[serverKey].containers?.forEach((c)=>{
+                if (c.uri === containerUri) setContainer(c);
+            });
+        });
     }, [
-        dataModel,
         dataServers,
-        setCreateContainer
+        setContainer,
+        containerUri
     ]);
-    return createContainer;
+    return container;
 };
-var $99ed32cbdb76cb50$export$2e2bcd8739ae039 = $99ed32cbdb76cb50$var$useCreateContainer;
+var $d3746ce11bc56f3b$export$2e2bcd8739ae039 = $d3746ce11bc56f3b$var$useContainerByUri;
 
 
 
 
 
 
+const $ff3623bf1421ebcc$var$findCreateContainerWithTypes = (types, createServerKey, dataServers)=>{
+    if (!dataServers[createServerKey].containers) throw new Error(`Data server ${createServerKey} has no declared containers`);
+    const matchingContainers = dataServers[createServerKey].containers.filter((container)=>container.types?.some((t)=>types.includes(t)));
+    if (matchingContainers.length === 0) throw new Error(`No container found matching with types ${JSON.stringify(types)}. You can set explicitly the create.container property of the resource.`);
+    else if (matchingContainers.length > 1) throw new Error(`More than one container found matching with types ${JSON.stringify(types)}. You must set the create.server or create.container property for the resource.`);
+    return matchingContainers[0].uri;
+};
+var $ff3623bf1421ebcc$export$2e2bcd8739ae039 = $ff3623bf1421ebcc$var$findCreateContainerWithTypes;
 
 
 
-const $20621bc841a5205a$var$useDataModels = ()=>{
-    const dataProvider = (0, $bkNnK$reactadmin.useDataProvider)();
-    const [dataModels, setDataModels] = (0, $bkNnK$react.useState)();
-    (0, $bkNnK$react.useEffect)(()=>{
-        dataProvider.getDataModels().then((results)=>{
-            setDataModels(results);
-        });
-    }, [
-        dataProvider,
-        setDataModels
-    ]);
-    return dataModels;
-};
-var $20621bc841a5205a$export$2e2bcd8739ae039 = $20621bc841a5205a$var$useDataModels;
-
 
-const $298b78bb7d4a3358$var$useCreateContainerUri = ()=>{
+const $32d32215b4e4729f$var$useGetCreateContainerUri = ()=>{
     const dataModels = (0, $20621bc841a5205a$export$2e2bcd8739ae039)();
     const dataServers = (0, $c9933a88e2acc4da$export$2e2bcd8739ae039)();
-    const getContainerUri = (0, $bkNnK$react.useCallback)((resourceId)=>{
+    const getCreateContainerUri = (0, $bkNnK$react.useCallback)((resourceId)=>{
         if (!dataModels || !dataServers || !dataModels[resourceId]) return undefined;
         const dataModel = dataModels[resourceId];
         if (dataModel.create?.container) {
             const [serverKey, path] = Object.entries(dataModel.create.container)[0];
             if (!serverKey || !dataServers[serverKey]) throw new Error(`Wrong key for the dataModel.create.container config of resource ${resourceId}`);
             return (0, ($parcel$interopDefault($bkNnK$urljoin)))(dataServers[serverKey].baseUrl, path);
+        } else if (dataModel.create?.server) return (0, $ff3623bf1421ebcc$export$2e2bcd8739ae039)(dataModel.types, dataModel.create?.server, dataServers);
+        else {
+            const defaultServerKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)('default', dataServers);
+            if (!defaultServerKey) throw new Error(`No default dataServer found. You can set explicitly one setting the "default" attribute to true`);
+            return (0, $ff3623bf1421ebcc$export$2e2bcd8739ae039)(dataModel.types, defaultServerKey, dataServers);
         }
-        if (dataModel.create?.server) return (0, $ff3623bf1421ebcc$export$2e2bcd8739ae039)(dataModel.types, dataModel.create?.server, dataServers);
-        const defaultServerKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)("default", dataServers);
-        if (!defaultServerKey) throw new Error(`No default dataServer found. You can set explicitly one setting the "default" attribute to true`);
-        return (0, $ff3623bf1421ebcc$export$2e2bcd8739ae039)(dataModel.types, defaultServerKey, dataServers);
     }, [
         dataModels,
         dataServers
     ]);
-    return getContainerUri;
+    return getCreateContainerUri;
+};
+var $32d32215b4e4729f$export$2e2bcd8739ae039 = $32d32215b4e4729f$var$useGetCreateContainerUri;
+
+
+const $298b78bb7d4a3358$var$useCreateContainerUri = (resourceId)=>{
+    const getCreateContainerUri = (0, $32d32215b4e4729f$export$2e2bcd8739ae039)();
+    const createContainerUri = (0, $bkNnK$react.useMemo)(()=>getCreateContainerUri(resourceId), [
+        getCreateContainerUri,
+        resourceId
+    ]);
+    return createContainerUri;
 };
 var $298b78bb7d4a3358$export$2e2bcd8739ae039 = $298b78bb7d4a3358$var$useCreateContainerUri;
 
 
 
+const $63a32f1a35c6f80e$var$useDataModel = (resourceId)=>{
+    const config = (0, $9def35f4441a9bb2$export$2e2bcd8739ae039)();
+    return config?.resources[resourceId];
+};
+var $63a32f1a35c6f80e$export$2e2bcd8739ae039 = $63a32f1a35c6f80e$var$useDataModel;
+
+
+
+
+
+
+
+
+const $85e9a897c6d7c14a$var$compute = (externalLinks, record)=>typeof externalLinks === 'function' ? externalLinks(record) : externalLinks;
+const $85e9a897c6d7c14a$var$isURL = (url)=>typeof url === 'string' && url.startsWith('http');
+const $85e9a897c6d7c14a$var$useGetExternalLink = (componentExternalLinks)=>{
+    // Since the externalLinks config is defined only locally, we don't need to wait for VOID endpoints fetching
+    const dataProvider = (0, $bkNnK$react.useContext)((0, $bkNnK$reactadmin.DataProviderContext));
+    const dataServers = dataProvider.getLocalDataServers();
+    const serversExternalLinks = (0, $bkNnK$react.useMemo)(()=>{
+        if (dataServers) return Object.fromEntries(Object.values(dataServers).map((server)=>{
+            // If externalLinks is not defined in the data server, use external links for non-default servers
+            const externalLinks = server.externalLinks !== undefined ? server.externalLinks : !server.default;
+            return [
+                server.baseUrl,
+                externalLinks
+            ];
+        }));
+    }, [
+        dataServers
+    ]);
+    return (0, $bkNnK$react.useCallback)((record)=>{
+        const computedComponentExternalLinks = $85e9a897c6d7c14a$var$compute(componentExternalLinks, record);
+        // If the component explicitly asks not to display as external links, use an internal link
+        if (computedComponentExternalLinks === false) return false;
+        if (!record?.id) return false;
+        const serverBaseUrl = Object.keys(serversExternalLinks).find((baseUrl)=>record?.id.startsWith(baseUrl));
+        // If no matching data servers could be found, assume we have an internal link
+        if (!serverBaseUrl) return false;
+        const computedServerExternalLinks = $85e9a897c6d7c14a$var$compute(serversExternalLinks[serverBaseUrl], record);
+        // If the data server explicitly asks not to display as external links, use an internal link
+        if (computedServerExternalLinks === false) return false;
+        if ($85e9a897c6d7c14a$var$isURL(computedComponentExternalLinks)) return computedComponentExternalLinks;
+        if ($85e9a897c6d7c14a$var$isURL(computedServerExternalLinks)) return computedServerExternalLinks;
+        return record.id;
+    }, [
+        serversExternalLinks,
+        componentExternalLinks
+    ]);
+};
+var $85e9a897c6d7c14a$export$2e2bcd8739ae039 = $85e9a897c6d7c14a$var$useGetExternalLink;
+
+
+
+
+
+const $d602250066d4ff3e$var$useGetPrefixFromUri = ()=>{
+    const config = (0, $9def35f4441a9bb2$export$2e2bcd8739ae039)();
+    return (0, $bkNnK$react.useCallback)((uri)=>(0, $8c4c0f0b55649ce6$export$2e2bcd8739ae039)(uri, config.ontologies), [
+        config?.ontologies
+    ]);
+};
+var $d602250066d4ff3e$export$2e2bcd8739ae039 = $d602250066d4ff3e$var$useGetPrefixFromUri;
 
 
 
@@ -1589,15 +1992,15 @@ var $b4703fef6d6af456$export$2e2bcd8739ae039 = $b4703fef6d6af456$var$GroupedRefe
 
 const $030f1232f6810456$var$useReferenceInputStyles = (0, ($parcel$interopDefault($bkNnK$muistylesmakeStyles)))({
     form: {
-        display: "flex"
+        display: 'flex'
     },
     input: {
-        paddingRight: "20px"
+        paddingRight: '20px'
     }
 });
 const $030f1232f6810456$var$useHideInputStyles = (0, ($parcel$interopDefault($bkNnK$muistylesmakeStyles)))({
     root: {
-        display: "none"
+        display: 'none'
     }
 });
 const $030f1232f6810456$var$ReificationArrayInput = (props)=>{
@@ -1633,21 +2036,21 @@ var $030f1232f6810456$export$2e2bcd8739ae039 = $030f1232f6810456$var$Reification
  * Find the solid notification description resource for a given resource URI.
  */ const $84ab912646919f8c$var$findDescriptionResource = async (authenticatedFetch, resourceUri)=>{
     const { headers: headers } = await authenticatedFetch(resourceUri, {
-        method: "HEAD"
+        method: 'HEAD'
     });
-    const linkHeader = headers.get("Link");
+    const linkHeader = headers.get('Link');
     const matches = linkHeader?.match(/<([^>]+)>;\s*rel="(?:describedby|http:\/\/www\.w3\.org\/ns\/solid\/terms#storageDescription)"/);
     if (!matches?.[1]) return undefined;
     // Don't use authenticatedFetch to get this endpoint
     const response = await fetch(matches[1], {
         headers: new Headers({
-            Accept: "application/ld+json"
+            Accept: 'application/ld+json'
         })
     });
     return await response.json();
 };
 const $84ab912646919f8c$export$3edfe18db119b920 = async (authenticatedFetch, resourceUri, options = {
-    type: "WebSocketChannel2023"
+    type: 'WebSocketChannel2023'
 })=>{
     const { type: type, closeAfter: closeAfter, startIn: startIn, rate: rate } = options;
     let { startAt: startAt, endAt: endAt } = options;
@@ -1657,13 +2060,13 @@ const $84ab912646919f8c$export$3edfe18db119b920 = async (authenticatedFetch, res
     // TODO: use a json-ld parser / ldo in the future for this...
     // Get solid notification subscription service for the given type.
     const subscriptionService = (await Promise.all(// Get the subscription service resources (that describe a channel type).
-    (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(descriptionResource.subscription || descriptionResource["notify:subscription"]).map(async (subscriptionServiceOrUri)=>{
+    (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(descriptionResource.subscription || descriptionResource['notify:subscription']).map(async (subscriptionServiceOrUri)=>{
         // They might not be resolved...
-        if (typeof subscriptionServiceOrUri === "string") {
+        if (typeof subscriptionServiceOrUri === 'string') {
             // Don't use authenticatedFetch to get this endpoint
             const response = await fetch(subscriptionServiceOrUri, {
                 headers: new Headers({
-                    Accept: "application/ld+json"
+                    Accept: 'application/ld+json'
                 })
             });
             return await response.json();
@@ -1671,16 +2074,16 @@ const $84ab912646919f8c$export$3edfe18db119b920 = async (authenticatedFetch, res
         return subscriptionServiceOrUri;
     }))).find((service)=>{
         // Find for the correct channel type (e.g. web socket).
-        const channelType = service.channelType ?? service["notify:channelType"];
+        const channelType = service.channelType ?? service['notify:channelType'];
         return channelType === type || channelType === `notify:${type}`;
     });
     if (!subscriptionService) throw new Error(`No solid notification subscription service found for type ${type}`);
     // Create a new channel.
-    const { json: channel } = await authenticatedFetch(subscriptionService.id || subscriptionService["@id"], {
-        method: "POST",
+    const { json: channel } = await authenticatedFetch(subscriptionService.id || subscriptionService['@id'], {
+        method: 'POST',
         body: JSON.stringify({
-            "@context": "https://www.w3.org/ns/solid/notifications-context/v1",
-            type: "WebSocketChannel2023",
+            '@context': 'https://www.w3.org/ns/solid/notifications-context/v1',
+            type: 'WebSocketChannel2023',
             topic: resourceUri,
             startAt: startAt,
             endAt: endAt,
@@ -1691,7 +2094,7 @@ const $84ab912646919f8c$export$3edfe18db119b920 = async (authenticatedFetch, res
 };
 const $84ab912646919f8c$export$28772ab4c256e709 = async (authenticatedFetch, resourceUri, options)=>{
     const channel = await $84ab912646919f8c$export$3edfe18db119b920(authenticatedFetch, resourceUri, options);
-    const receiveFrom = channel.receiveFrom || channel["notify:receiveFrom"];
+    const receiveFrom = channel.receiveFrom || channel['notify:receiveFrom'];
     return new WebSocket(receiveFrom);
 };
 const $84ab912646919f8c$var$registeredWebSockets = new Map();
@@ -1701,7 +2104,7 @@ const $84ab912646919f8c$var$registeredWebSockets = new Map();
  * @param options Options to pass to @see createSolidNotificationChannel, if the channel does not exist yet.
  * @returns {WebSocket} A new or existing web socket that subscribed to the given resource.
  */ const $84ab912646919f8c$export$8d60734939c59ced = async (authenticatedFetch, resourceUri, options = {
-    type: "WebSocketChannel2023",
+    type: 'WebSocketChannel2023',
     closeAfter: 3600000
 })=>{
     const socket = $84ab912646919f8c$var$registeredWebSockets.get(resourceUri);
@@ -1711,10 +2114,10 @@ const $84ab912646919f8c$var$registeredWebSockets = new Map();
     // This prevents racing conditions that create multiple channels.
     const wsPromise = $84ab912646919f8c$export$28772ab4c256e709(authenticatedFetch, resourceUri, {
         ...options,
-        type: "WebSocketChannel2023"
+        type: 'WebSocketChannel2023'
     }).then((ws)=>{
         // Remove the promise from the cache, if it closes.
-        ws.addEventListener("close", (e)=>{
+        ws.addEventListener('close', (e)=>{
             $84ab912646919f8c$var$registeredWebSockets.delete(resourceUri);
         });
         // Close the socket, if the endAt / closeAfter time is reached.