@data-fair/lib-node 2.11.0 → 2.12.1

package/axios-auth.d.ts

@@ -1,5 +1,4 @@
-import type { AxiosInstance } from 'axios';
-import { CookieJar } from 'tough-cookie';
+import { type AxiosWithCookiesInstance } from './axios-with-cookies.js';
 export interface AxiosAuthOptions {
     email: string;
     password: string;
@@ -11,8 +10,7 @@ export interface AxiosAuthOptions {
     orgStorage?: boolean;
     globalCookies?: boolean;
 }
-export type AxiosAuthInstance = AxiosInstance & {
-    cookieJar: CookieJar;
+export type AxiosAuthInstance = AxiosWithCookiesInstance & {
     setOrg: (org: string, dep?: string) => void;
 };
 export declare function axiosAuth(opts: AxiosAuthOptions): Promise<AxiosAuthInstance>;

package/axios-auth.js

@@ -1,13 +1,9 @@
 // build axios instances with sessions on a simple-directory instance
 // WARNING: use for integration testing only
 import { Agent } from 'node:http';
-import { axiosBuilder, axiosInstance } from './axios.js';
 import { CookieJar } from 'tough-cookie';
-const getConfigUrl = (config) => {
-    if (!config.url)
-        throw new Error('url is required');
-    return new URL((config.baseURL && config.url?.startsWith('/')) ? (config.baseURL + config.url) : config.url);
-};
+import { axiosInstance } from './axios.js';
+import { axiosWithCookies } from './axios-with-cookies.js';
 export async function axiosAuth(opts) {
     const body = { email: opts.email, password: opts.password };
     if (opts.org)
@@ -28,8 +24,8 @@ export async function axiosAuth(opts) {
     if (callbackUrl.startsWith(directoryUrl + '/simple-directory')) {
         callbackUrl = callbackUrl.replace(directoryUrl + '/simple-directory', directoryUrl);
     }
-    const cookieJar = new CookieJar();
     const sdOrigin = new URL(directoryUrl).origin;
+    const cookieJar = new CookieJar();
     try {
         await axiosInstance.get(callbackUrl, { maxRedirects: 0 });
     }
@@ -43,38 +39,15 @@ export async function axiosAuth(opts) {
         for (const cookie of err.headers['set-cookie'] ?? [])
             cookieJar.setCookieSync(cookie, sdOrigin);
     }
-    const ax = axiosBuilder(axiosOpts, (ax) => {
-        ax.interceptors.request.use((config) => {
-            const url = getConfigUrl(config);
-            // if opts.globalCookies is true the cookie jar is used to store cookies shared accross all domains
-            // this behavior is useful for testing purposes if serves are not on the same domain
-            if (!opts.globalCookies || url.origin === sdOrigin) {
-                config.headers.Cookie = cookieJar.getCookiesSync(url.href);
-            }
-            else {
-                config.headers.Cookie = cookieJar.getCookiesSync(sdOrigin);
-            }
-            return config;
-        });
-        ax.interceptors.response.use((res) => {
-            const origin = opts.globalCookies ? sdOrigin : getConfigUrl(res.config).origin;
-            for (const cookie of res.headers['set-cookie'] ?? [])
-                cookieJar.setCookieSync(cookie, origin);
-            return res;
-        }, async (error) => {
-            const res = error.response;
-            if (res) {
-                const origin = opts.globalCookies ? sdOrigin : getConfigUrl(res.config).origin;
-                for (const cookie of res.headers['set-cookie'] ?? [])
-                    cookieJar.setCookieSync(cookie, origin);
-            }
-            return Promise.reject(error);
-        });
+    const ax = axiosWithCookies({
+        axiosOpts,
+        cookiesOrigin: sdOrigin,
+        globalCookies: opts.globalCookies,
+        cookieJar
     });
-    ax.cookieJar = cookieJar;
     ax.setOrg = (org, dep) => {
-        cookieJar.setCookieSync(`id_token_org=${org}`, sdOrigin);
-        cookieJar.setCookieSync(`id_token_dep=${dep ?? ''}`, sdOrigin);
+        ax.cookieJar.setCookieSync(`id_token_org=${org}`, sdOrigin);
+        ax.cookieJar.setCookieSync(`id_token_dep=${dep ?? ''}`, sdOrigin);
     };
     return ax;
 }

package/axios-with-cookies.d.ts

@@ -0,0 +1,13 @@
+import type { AxiosInstance } from 'axios';
+import { CookieJar } from 'tough-cookie';
+export interface AxiosWithCookiesOptions {
+    axiosOpts?: any;
+    cookiesOrigin?: string;
+    globalCookies?: boolean;
+    cookieJar?: CookieJar;
+}
+export type AxiosWithCookiesInstance = AxiosInstance & {
+    cookieJar: CookieJar;
+};
+export declare function axiosWithCookies(opts?: AxiosWithCookiesOptions): AxiosWithCookiesInstance;
+export default axiosWithCookies;

package/axios-with-cookies.js

@@ -0,0 +1,41 @@
+// build axios instances with cookie jar support
+import { axiosBuilder } from './axios.js';
+import { CookieJar } from 'tough-cookie';
+const getConfigUrl = (config) => {
+    if (!config.url)
+        throw new Error('url is required');
+    return new URL((config.baseURL && config.url?.startsWith('/')) ? (config.baseURL + config.url) : config.url);
+};
+export function axiosWithCookies(opts = {}) {
+    const cookieJar = opts.cookieJar ?? new CookieJar();
+    const cookiesOrigin = opts.cookiesOrigin ?? '';
+    const ax = axiosBuilder(opts.axiosOpts, (ax) => {
+        ax.interceptors.request.use((config) => {
+            const url = getConfigUrl(config);
+            if (!opts.globalCookies || url.origin === cookiesOrigin) {
+                config.headers.Cookie = cookieJar.getCookiesSync(url.href);
+            }
+            else {
+                config.headers.Cookie = cookieJar.getCookiesSync(cookiesOrigin);
+            }
+            return config;
+        });
+        ax.interceptors.response.use((res) => {
+            const origin = opts.globalCookies ? cookiesOrigin : getConfigUrl(res.config).origin;
+            for (const cookie of res.headers['set-cookie'] ?? [])
+                cookieJar.setCookieSync(cookie, origin);
+            return res;
+        }, async (error) => {
+            const res = error.response;
+            if (res) {
+                const origin = opts.globalCookies ? cookiesOrigin : getConfigUrl(res.config).origin;
+                for (const cookie of res.headers['set-cookie'] ?? [])
+                    cookieJar.setCookieSync(cookie, origin);
+            }
+            return Promise.reject(error);
+        });
+    });
+    ax.cookieJar = cookieJar;
+    return ax;
+}
+export default axiosWithCookies;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@data-fair/lib-node",
-  "version": "2.11.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;
     }
 }