@data-fair/lib-node 2.12.0 → 2.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@data-fair/lib-node",
-  "version": "2.12.0",
+  "version": "2.12.1",
   "description": "Small nodejs related utility functions for the data-fair stack.",
   "main": "index.js",
   "files": [

package/session.test.d.ts

@@ -0,0 +1 @@
+export {};

package/session.test.js

@@ -0,0 +1,40 @@
+import { describe, it } from 'node:test';
+import { strict as assert } from 'assert';
+import { SessionHandler } from './session.js';
+describe('SessionHandler.readStateFromCookie', () => {
+    it('should return default session with no cookies', async () => {
+        const handler = new SessionHandler();
+        const state = await handler.readStateFromCookie(undefined);
+        assert.equal(state.lang, 'fr');
+        assert.equal(state.user, undefined);
+        assert.equal(state.dark, undefined);
+    });
+    it('should parse dark mode cookie', async () => {
+        const handler = new SessionHandler();
+        const state = await handler.readStateFromCookie('theme_dark=true');
+        assert.equal(state.dark, true);
+    });
+    it('should parse i18n_lang cookie', async () => {
+        const handler = new SessionHandler();
+        const state = await handler.readStateFromCookie('i18n_lang=en');
+        assert.equal(state.lang, 'en');
+    });
+    it('should use defaultLang when no i18n_lang cookie', async () => {
+        const handler = new SessionHandler();
+        handler.defaultLang = 'de';
+        const state = await handler.readStateFromCookie('');
+        assert.equal(state.lang, 'de');
+    });
+    it('should return early when no id_token', async () => {
+        const handler = new SessionHandler();
+        const state = await handler.readStateFromCookie('i18n_lang=en; theme_dark=1');
+        assert.equal(state.lang, 'en');
+        assert.equal(state.dark, true);
+        assert.equal(state.user, undefined);
+    });
+    it('should return early when no id_token_sign and not onlyDecode', async () => {
+        const handler = new SessionHandler();
+        const state = await handler.readStateFromCookie('id_token=header.payload');
+        assert.equal(state.user, undefined);
+    });
+});

package/ws-client.d.ts

@@ -1,6 +1,9 @@
 import { type Message } from '@data-fair/lib-common-types/ws.js';
 import { type Account } from '@data-fair/lib-common-types/session/index.js';
 import EventEmitter from 'node:events';
+declare class WsClientError extends Error {
+    constructor();
+}
 type logFn = (msg: string, ...args: any[]) => void;
 export interface WsClientOpts {
     log?: {
@@ -23,7 +26,7 @@ export declare class WsClient extends EventEmitter {
     private _connect;
     private _reconnect;
     subscribe(channel: string, force?: boolean, timeout?: number): Promise<void>;
-    waitFor(channel: string, filter?: (message: Message) => boolean, timeout?: number, skipSubscribe?: boolean, fullMessage?: boolean): Promise<Message>;
+    waitFor(channel: string, filter?: (message: Message) => boolean, timeout?: number, skipSubscribe?: boolean, fullMessage?: boolean, _errorContext?: WsClientError): Promise<Message>;
     close(): void;
 }
 export declare class DataFairWsClient extends WsClient {

package/ws-client.js

@@ -4,6 +4,13 @@ import EventEmitter from 'node:events';
 import WebSocket from 'ws';
 import Debug from 'debug';
 const debug = Debug('ws');
+const { stackTraceLimit } = Error;
+class WsClientError extends Error {
+    constructor() {
+        super();
+        this.name = 'WsClientError';
+    }
+}
 export class WsClient extends EventEmitter {
     _channels;
     _ws;
@@ -49,6 +56,12 @@ export class WsClient extends EventEmitter {
         if (this._channels.includes(channel) && !force)
             return;
         const ws = this._ws ?? await this._connect();
+        // better stack traces
+        // see https://github.com/axios/axios/issues/2387#issuecomment-652242713
+        Error.stackTraceLimit = 0;
+        const errorContext = new WsClientError();
+        Error.stackTraceLimit = stackTraceLimit;
+        Error.captureStackTrace(errorContext, this.subscribe);
         debug('subscribe to channel', channel);
         const subscribeMessage = { type: 'subscribe', channel };
         if (this.opts.apiKey)
@@ -58,17 +71,37 @@ export class WsClient extends EventEmitter {
         ws.send(JSON.stringify(subscribeMessage));
         const event = await this.waitFor(channel, (e) => {
             return e.type === 'subscribe-confirm' || e.type === 'error';
-        }, timeout, true, true);
-        if (event.type === 'error')
-            throw new Error(event.data);
+        }, timeout, true, true, errorContext);
+        if (event.type === 'error') {
+            const error = new Error(event.data);
+            error.stack += '\nSubscribe context:\n' + errorContext.stack;
+            throw error;
+        }
         if (this._channels.includes(channel))
             this._channels.push(channel);
     }
-    async waitFor(channel, filter, timeout = 300000, skipSubscribe = false, fullMessage = false) {
+    async waitFor(channel, filter, timeout = 300000, skipSubscribe = false, fullMessage = false, _errorContext) {
         if (!skipSubscribe)
             await this.subscribe(channel);
+        // better stack traces
+        // see https://github.com/axios/axios/issues/2387#issuecomment-652242713
+        let errorContext;
+        if (_errorContext) {
+            errorContext = _errorContext;
+        }
+        else {
+            Error.stackTraceLimit = 0;
+            errorContext = new WsClientError();
+            Error.stackTraceLimit = stackTraceLimit;
+            Error.captureStackTrace(errorContext, this.waitFor);
+        }
         return await new Promise((resolve, reject) => {
-            const _timeout = setTimeout(() => { reject(new Error('timeout')); }, timeout);
+            const _timeout = setTimeout(() => {
+                this.off('message', messageCb);
+                const error = new Error(`Timeout of ${timeout}ms exceeded`);
+                error.stack += '\nWaitFor context:\n' + errorContext.stack;
+                reject(error);
+            }, timeout);
             const messageCb = (message) => {
                 if (message.channel === channel && (!filter || filter(fullMessage ? message : message.data))) {
                     clearTimeout(_timeout);
@@ -87,11 +120,20 @@ export class WsClient extends EventEmitter {
 export class DataFairWsClient extends WsClient {
     async waitForJournal(datasetId, eventType, timeout = 300000) {
         await this.opts.log.info(`wait for event "${eventType}" on dataset "${datasetId}"`);
+        // better stack traces
+        // see https://github.com/axios/axios/issues/2387#issuecomment-652242713
+        Error.stackTraceLimit = 0;
+        const errorContext = new WsClientError();
+        Error.stackTraceLimit = stackTraceLimit;
+        Error.captureStackTrace(errorContext, this.waitForJournal);
         const event = await this.waitFor(`datasets/${datasetId}/journal`, (e) => {
             return e.type === eventType || e.type === 'error';
-        }, timeout);
-        if (event.type === 'error')
-            throw new Error(event.data);
+        }, timeout, false, false, errorContext);
+        if (event.type === 'error') {
+            const error = new Error(event.data);
+            error.stack += '\nWaitForJournal context:\n' + errorContext.stack;
+            throw error;
+        }
         return event;
     }
 }