@data-fair/dev-server 2.6.2 → 2.6.4

package/README.md

@@ -50,10 +50,9 @@ développement, dans la même version mineure. La recherche part du nom lu dans
 balise `<meta name="application-name">` de l'`index.html` local et de la version
 du `package.json`.
 
-Une application de base réservée à une organisation (`privateAccess`) est
-invisible à une requête anonyme. Le paramètre `privateAccess` la rend visible,
-mais data-fair répond 401 sans authentification — il n'est donc envoyé que si
-`DATAFAIR_API_KEY` est renseignée.
+Une application de base réservée à une organisation (`privateAccess`) reste
+invisible : data-fair ne lit pas la clé d'API sur `/base-applications` et répond
+401 au paramètre `privateAccess`, que le dev-server n'envoie donc pas.
 
 Ne pas la trouver n'arrête pas la recherche pour autant : les applications qui
 tournent dessus sont souvent publiques, et il suffit de connaître son URL pour

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@data-fair/dev-server",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "A development server for optimal development experience of data-fair applications.",
   "main": "src/index.js",
   "bin": {

package/src/app.js

@@ -30,42 +30,62 @@ let devServerWS = [];
 let dataFairWS = [];
 const dataFairWSChannels = new Map();
 const dfWsUrl = config.dataFair.url.replace('http://', 'ws://').replace('https://', 'wss://') + '/';
-const dataFairOutputWS = new WebSocket(dfWsUrl);
-dataFairOutputWS.on('open', () => {
-    debug('connect to external websocket server ' + dfWsUrl);
-});
-dataFairOutputWS.on('message', (data) => {
-    const dataStr = data.toString();
-    const message = JSON.parse(dataStr);
-    debug('incoming message from data-fair socket', message);
-    for (const ws of dataFairWS) {
-        if (dataFairWSChannels.get(ws)?.includes(message.channel)) {
-            ws.send(dataStr);
+// the connection to data-fair is reopened whenever it closes (network change, data-fair restart),
+// and the channels of the connected apps are subscribed again on it
+let dataFairOutputWS;
+const subscribe = (channel) => {
+    const message = { type: 'subscribe', channel };
+    if (config.dataFair.apiKey)
+        message.apiKey = config.dataFair.apiKey;
+    dataFairOutputWS.send(JSON.stringify(message));
+};
+const connectDataFairWS = () => {
+    dataFairOutputWS = new WebSocket(dfWsUrl);
+    dataFairOutputWS.on('open', () => {
+        debug('connect to external websocket server ' + dfWsUrl);
+        for (const channel of new Set([...dataFairWSChannels.values()].flat()))
+            subscribe(channel);
+    });
+    dataFairOutputWS.on('message', (data) => {
+        const dataStr = data.toString();
+        const message = JSON.parse(dataStr);
+        debug('incoming message from data-fair socket', message);
+        for (const ws of dataFairWS) {
+            if (dataFairWSChannels.get(ws)?.includes(message.channel)) {
+                ws.send(dataStr);
+            }
         }
-    }
-});
-dataFairOutputWS.on('error', (err) => console.error('failed to connect to external websocket server', dfWsUrl, err));
-dataFairOutputWS.on('close', () => console.error('external websocket was closed', dfWsUrl));
+    });
+    dataFairOutputWS.on('error', (err) => console.error('failed to connect to external websocket server', dfWsUrl, err));
+    dataFairOutputWS.on('close', () => {
+        console.error('external websocket was closed, reconnecting in 2s', dfWsUrl);
+        setTimeout(connectDataFairWS, 2000);
+    });
+};
+connectDataFairWS();
 server.on('upgrade', function upgrade(req, socket, head) {
     wss.handleUpgrade(req, socket, head, (ws) => {
         debug('Opening websocket ' + req.url);
         if (req.url === '/data-fair' || req.url === '/data-fair/') {
             dataFairWS.push(ws);
-            ws.on('close', () => { dataFairWS = dataFairWS.filter(_ws => _ws !== ws); });
+            ws.on('close', () => {
+                dataFairWS = dataFairWS.filter(_ws => _ws !== ws);
+                dataFairWSChannels.delete(ws);
+            });
             ws.on('message', (data) => {
-                if (dataFairOutputWS) {
-                    const message = JSON.parse(data);
-                    debug('outgoing message to data-fair socket', message);
-                    if (message.type === 'subscribe') {
-                        dataFairWSChannels.set(ws, (dataFairWSChannels.get(ws) ?? []).concat([message.channel]));
-                        if (config.dataFair.apiKey)
-                            message.apiKey = config.dataFair.apiKey;
-                    }
-                    if (message.type === 'unsubscribe') {
-                        dataFairWSChannels.set(ws, (dataFairWSChannels.get(ws) ?? []).filter(c => c !== message.channel));
-                    }
-                    dataFairOutputWS.send(JSON.stringify(message));
+                const message = JSON.parse(data);
+                debug('outgoing message to data-fair socket', message);
+                if (message.type === 'subscribe') {
+                    dataFairWSChannels.set(ws, (dataFairWSChannels.get(ws) ?? []).concat([message.channel]));
+                    if (config.dataFair.apiKey)
+                        message.apiKey = config.dataFair.apiKey;
+                }
+                if (message.type === 'unsubscribe') {
+                    dataFairWSChannels.set(ws, (dataFairWSChannels.get(ws) ?? []).filter(c => c !== message.channel));
                 }
+                // while data-fair is unreachable the subscriptions are only recorded, the open handler sends them
+                if (dataFairOutputWS.readyState === WebSocket.OPEN)
+                    dataFairOutputWS.send(JSON.stringify(message));
             });
         }
         else if (req.url === '/') {
@@ -164,15 +184,6 @@ const localAppInfo = async () => {
     }
     return { name, version, packageName };
 };
-// The owner the dev-server works on behalf of, in the "type:id[:department]" form the
-// data-fair api expects for its owner and privateAccess filters.
-const ownerFilter = () => {
-    const owner = config.dataFair.owner;
-    let filter = `${owner.type}:${owner.id}`;
-    if (owner.department)
-        filter += ':' + owner.department;
-    return filter;
-};
 // Enrich the datasets from the remote data-fair and rewrite every remote origin to ours
 // (pure helpers in enrich.ts, wired here to our remote api and local origins).
 const prepareConfig = (configuration) => prepareRemoteConfig(configuration, {
@@ -323,15 +334,12 @@ app.get('/configurations', async (req, res) => {
         return;
     }
     response.minorVersion = minorVersion(version);
-    // a base application restricted to an organization is invisible to an anonymous request.
-    // privateAccess is what makes it visible, and data-fair answers 401 to it without
-    // credentials, so it is only sent when an api key is configured.
     response.authenticated = !!config.dataFair.apiKey;
     try {
-        let baseAppsQuery = '/base-applications?applicationName=' + encodeURIComponent(name) + '&size=1000&count=false';
-        if (response.authenticated)
-            baseAppsQuery += '&privateAccess=' + encodeURIComponent(ownerFilter());
-        const baseApps = await remoteFetch(baseAppsQuery);
+        // no privateAccess filter: data-fair reads no api key on /base-applications and answers 401
+        // to it, so a base application restricted to an organization stays invisible here and is
+        // reached by guessing its url below
+        const baseApps = await remoteFetch('/base-applications?applicationName=' + encodeURIComponent(name) + '&size=1000&count=false');
         const matchingBaseApps = (baseApps.results ?? []).filter((b) => typeof b.version === 'string' && minorVersion(b.version) === response.minorVersion);
         // Not finding the base application is not the end of the search: it may simply be private
         // while the applications running on it are public, and those are reachable as soon as its