@data-fair/lib-node 2.8.1 → 2.9.0

package/axios-auth.js

@@ -1,69 +1,81 @@
 // 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'
+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)
+    if (!config.url)
+        throw new Error('url is required');
+    return new URL((config.baseURL && config.url?.startsWith('/')) ? (config.baseURL + config.url) : config.url);
+};
+export async function axiosAuth(opts) {
+    const body = { email: opts.email, password: opts.password };
+    if (opts.org)
+        body.org = opts.org;
+    if (opts.dep)
+        body.dep = opts.dep;
+    if (opts.adminMode)
+        body.adminMode = opts.adminMode;
+    if (opts.orgStorage)
+        body.orgStorage = opts.orgStorage;
+    const axiosOpts = {
+        httpAgent: new Agent({ keepAlive: false }),
+        maxRedirects: 0,
+        ...opts.axiosOpts
+    };
+    const directoryUrl = opts.directoryUrl ?? 'http://localhost:8080';
+    let callbackUrl = (await axiosInstance.post(directoryUrl + '/api/auth/password', body, { params: { redirect: directoryUrl }, maxRedirects: 0 })).data;
+    if (callbackUrl.startsWith(directoryUrl + '/simple-directory')) {
+        callbackUrl = callbackUrl.replace(directoryUrl + '/simple-directory', directoryUrl);
+    }
+    const cookieJar = new CookieJar();
+    const sdOrigin = new URL(directoryUrl).origin;
+    try {
+        await axiosInstance.get(callbackUrl, { maxRedirects: 0 });
+    }
+    catch (err) {
+        if (err.status !== 302)
+            throw err;
+        const redirectUrl = new URL(err.headers.location);
+        const redirectError = redirectUrl.searchParams.get('error');
+        if (redirectError)
+            throw new Error(redirectError);
+        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);
+        });
+    });
+    ax.cookieJar = cookieJar;
+    ax.setOrg = (org, dep) => {
+        cookieJar.setCookieSync(`id_token_org=${org}`, sdOrigin);
+        cookieJar.setCookieSync(`id_token_dep=${dep ?? ''}`, sdOrigin);
+    };
+    return ax;
 }
-export async function axiosAuth (opts) {
-  const body = { email: opts.email, password: opts.password }
-  if (opts.org) { body.org = opts.org }
-  if (opts.dep) { body.dep = opts.dep }
-  if (opts.adminMode) { body.adminMode = opts.adminMode }
-  if (opts.orgStorage) { body.orgStorage = opts.orgStorage }
-  const axiosOpts = {
-    httpAgent: new Agent({ keepAlive: false }),
-    maxRedirects: 0,
-    ...opts.axiosOpts
-  }
-  const directoryUrl = opts.directoryUrl ?? 'http://localhost:8080'
-  let callbackUrl = (await axiosInstance.post(directoryUrl + '/api/auth/password', body, { params: { redirect: directoryUrl }, maxRedirects: 0 })).data
-  if (callbackUrl.startsWith(directoryUrl + '/simple-directory')) {
-    callbackUrl = callbackUrl.replace(directoryUrl + '/simple-directory', directoryUrl)
-  }
-  const cookieJar = new CookieJar()
-  const sdOrigin = new URL(directoryUrl).origin
-  try {
-    await axiosInstance.get(callbackUrl, { maxRedirects: 0 })
-  } catch (err) {
-    if (err.status !== 302) { throw err }
-    const redirectUrl = new URL(err.headers.location)
-    const redirectError = redirectUrl.searchParams.get('error')
-    if (redirectError) { throw new Error(redirectError) }
-    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)
-    })
-  })
-  ax.cookieJar = cookieJar
-  ax.setOrg = (org, dep) => {
-    cookieJar.setCookieSync(`id_token_org=${org}`, sdOrigin)
-    cookieJar.setCookieSync(`id_token_dep=${dep ?? ''}`, sdOrigin)
-  }
-  return ax
-}
-export default axiosAuth
+export default axiosAuth;

package/axios.js

@@ -1,51 +1,55 @@
 // prepare an axios instance with improved error management and some performance tuning for nodejs usage
-import axios from 'axios'
-import { httpAgent, httpsAgent } from './http-agents.js'
-const { stackTraceLimit } = Error
+import axios from 'axios';
+import { httpAgent, httpsAgent } from './http-agents.js';
+const { stackTraceLimit } = Error;
 class AxiosRequestError extends Error {
-  constructor () {
-    super()
-    this.name = 'AxiosRequestError'
-  }
+    constructor() {
+        super();
+        this.name = 'AxiosRequestError';
+    }
 }
 const requestInterceptor = (config) => {
-  // better stack traces
-  // see https://github.com/axios/axios/issues/2387#issuecomment-652242713
-  Error.stackTraceLimit = 0
-  const errorContext = new AxiosRequestError()
-  Error.stackTraceLimit = stackTraceLimit
-  Error.captureStackTrace(errorContext, requestInterceptor)
-  // @ts-ignore
-  config.errorContext = errorContext
-  return config
-}
-export function axiosBuilder (opts = {}, beforeInterceptors) {
-  const ax = axios.create({
-    httpAgent,
-    httpsAgent,
-    ...opts
-  })
-  if (beforeInterceptors) { beforeInterceptors(ax) }
-  ax.interceptors.request.use(requestInterceptor)
-  // shorter stack traces
-  ax.interceptors.response.use(response => response, error => {
-    if (!error.response) {
-      if (error.config?.errorContext?.stack) { error.stack += '\nRequest context:\n' + error.config?.errorContext?.stack }
-      return Promise.reject(error)
-    }
-    delete error.response.request
-    error.response.config = { method: error.response.config.method, url: error.response.config.url, data: error.response.config.data }
-    if (error.response.config.data && error.response.config.data._writableState) { delete error.response.config.data }
-    if (error.response.data && error.response.data._readableState) { delete error.response.data }
-    let messageText = error.response.statusText
-    if (error.response.data) {
-      messageText = typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data)
-    }
-    error.response.message = `${error.response.status} - ${messageText}`
-    Object.assign(error.config.errorContext, error.response)
-    return Promise.reject(error.config.errorContext)
-  })
-  return ax
+    // better stack traces
+    // see https://github.com/axios/axios/issues/2387#issuecomment-652242713
+    Error.stackTraceLimit = 0;
+    const errorContext = new AxiosRequestError();
+    Error.stackTraceLimit = stackTraceLimit;
+    Error.captureStackTrace(errorContext, requestInterceptor);
+    // @ts-ignore
+    config.errorContext = errorContext;
+    return config;
+};
+export function axiosBuilder(opts = {}, beforeInterceptors) {
+    const ax = axios.create({
+        httpAgent,
+        httpsAgent,
+        ...opts
+    });
+    if (beforeInterceptors)
+        beforeInterceptors(ax);
+    ax.interceptors.request.use(requestInterceptor);
+    // shorter stack traces
+    ax.interceptors.response.use(response => response, error => {
+        if (!error.response) {
+            if (error.config?.errorContext?.stack)
+                error.stack += '\nRequest context:\n' + error.config?.errorContext?.stack;
+            return Promise.reject(error);
+        }
+        delete error.response.request;
+        error.response.config = { method: error.response.config.method, url: error.response.config.url, data: error.response.config.data };
+        if (error.response.config.data && error.response.config.data._writableState)
+            delete error.response.config.data;
+        if (error.response.data && error.response.data._readableState)
+            delete error.response.data;
+        let messageText = error.response.statusText;
+        if (error.response.data) {
+            messageText = typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data);
+        }
+        error.response.message = `${error.response.status} - ${messageText}`;
+        Object.assign(error.config.errorContext, error.response);
+        return Promise.reject(error.config.errorContext);
+    });
+    return ax;
 }
-export const axiosInstance = axiosBuilder()
-export default axiosInstance
+export const axiosInstance = axiosBuilder();
+export default axiosInstance;

package/events-queue.d.ts

@@ -1,11 +1,13 @@
 import { type Event } from '@data-fair/lib-common-types/event/index.js';
 import { type Notification } from '@data-fair/lib-common-types/notification/index.js';
 import { SessionState } from '@data-fair/lib-common-types/session/index.js';
-type EventsQueueOptions = {
+export type EventsQueueOptions = {
     eventsUrl: string;
     eventsSecret: string;
     inactive?: boolean;
 };
+export type PushEvent = Omit<Event, 'date'>;
+export type PushNotification = Omit<Notification, 'date'>;
 export declare class EventsQueue {
     _options: EventsQueueOptions | undefined;
     eventsQueue: Event[];
@@ -17,8 +19,8 @@ export declare class EventsQueue {
     stop: () => Promise<void>;
     loop(): Promise<void>;
     drain(): Promise<void>;
-    pushEvent(event: Omit<Event, 'date'>, sessionState?: SessionState): void;
-    pushNotification(notification: Omit<Notification, 'date'>): void;
+    pushEvent(event: PushEvent, sessionState?: SessionState): void;
+    pushNotification(notification: PushNotification): void;
 }
 declare const eventsQueue: EventsQueue;
 export default eventsQueue;

package/events-queue.js

@@ -1,110 +1,116 @@
-import { internalError } from '@data-fair/lib-node/observer.js'
-import axios from './axios.js'
-import Debug from 'debug'
-const debug = Debug('events-queue')
+import { internalError } from '@data-fair/lib-node/observer.js';
+import axios from './axios.js';
+import Debug from 'debug';
+const debug = Debug('events-queue');
 export class EventsQueue {
-  _options
-  eventsQueue = []
-  notificationsQueue = []
-  stopped = false
-  currentDrainPromise
-  options () {
-    if (!this._options) { throw new Error('events queue was not initialized') }
-    return this._options
-  }
-
-  start = async (options) => {
-    if (this._options) { throw new Error('events queue was already initialized') }
-    this._options = options
-    this.loop()
-  }
-
-  stop = async () => {
-    this.stopped = true
-    if (this.currentDrainPromise) { await this.currentDrainPromise }
-    await this.drain()
-  }
-
-  async loop () {
-    while (!this.stopped) {
-      await new Promise(resolve => setTimeout(resolve, 3000))
-      this.currentDrainPromise = this.drain()
-      await this.currentDrainPromise
-      this.currentDrainPromise = undefined
+    _options;
+    eventsQueue = [];
+    notificationsQueue = [];
+    stopped = false;
+    currentDrainPromise;
+    options() {
+        if (!this._options)
+            throw new Error('events queue was not initialized');
+        return this._options;
     }
-  }
-
-  async drain () {
-    if (this.eventsQueue.length) {
-      const events = this.eventsQueue
-      this.eventsQueue = []
-      debug('drain events', events.length)
-      try {
-        await axios.post(this.options().eventsUrl + '/api/events', events, { headers: { 'x-secret-key': this.options().eventsSecret } })
-      } catch (err) {
-        internalError('events-queue-push-event', err)
-        // retry later
-        if (err.status >= 500 && events.length < 1000) { this.eventsQueue = events.concat(this.eventsQueue) }
-      }
-    }
-    if (this.notificationsQueue.length) {
-      const notifications = this.notificationsQueue
-      this.notificationsQueue = []
-      debug('drain notifications', notifications.length)
-      for (const notification of notifications) {
-        try {
-          await axios.post(this.options().eventsUrl + '/api/notifications', notification, { headers: { 'x-secret-key': this.options().eventsSecret } })
-        } catch (err) {
-          internalError('events-queue-push-notif', err)
-          // retry later
-          if (err.status >= 500 && (notifications.length + this.notificationsQueue.length) < 1000) {
-            this.notificationsQueue.unshift()
-          }
+    start = async (options) => {
+        if (this._options)
+            throw new Error('events queue was already initialized');
+        this._options = options;
+        this.loop();
+    };
+    stop = async () => {
+        this.stopped = true;
+        if (this.currentDrainPromise)
+            await this.currentDrainPromise;
+        await this.drain();
+    };
+    async loop() {
+        while (!this.stopped) {
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            this.currentDrainPromise = this.drain();
+            await this.currentDrainPromise;
+            this.currentDrainPromise = undefined;
         }
-      }
     }
-  }
-
-  pushEvent (event, sessionState) {
-    const options = this.options()
-    if (options.inactive) { return }
-    if (this.stopped) { throw new Error('events queue has been stopped') }
-    event.date = new Date().toISOString()
-    debug('pushEvent', event)
-    if (!event.originator && sessionState?.user && sessionState.account) {
-      if (sessionState.user.asAdmin) {
-        event.originator = {
-          user: { ...sessionState.user.asAdmin, admin: true }
-        }
-      } else if (sessionState.user.adminMode && (sessionState.account.type !== event.sender?.type || sessionState.account.id !== event.sender?.id)) {
-        event.originator = {
-          user: { id: sessionState.user.id, name: sessionState.user.name, admin: true }
+    async drain() {
+        if (this.eventsQueue.length) {
+            const events = this.eventsQueue;
+            this.eventsQueue = [];
+            debug('drain events', events.length);
+            try {
+                await axios.post(this.options().eventsUrl + '/api/events', events, { headers: { 'x-secret-key': this.options().eventsSecret } });
+            }
+            catch (err) {
+                internalError('events-queue-push-event', err);
+                // retry later
+                if (err.status >= 500 && events.length < 1000)
+                    this.eventsQueue = events.concat(this.eventsQueue);
+            }
         }
-      } else {
-        event.originator = {
-          user: { id: sessionState.user.id, name: sessionState.user.name }
+        if (this.notificationsQueue.length) {
+            const notifications = this.notificationsQueue;
+            this.notificationsQueue = [];
+            debug('drain notifications', notifications.length);
+            for (const notification of notifications) {
+                try {
+                    await axios.post(this.options().eventsUrl + '/api/notifications', notification, { headers: { 'x-secret-key': this.options().eventsSecret } });
+                }
+                catch (err) {
+                    internalError('events-queue-push-notif', err);
+                    // retry later
+                    if (err.status >= 500 && (notifications.length + this.notificationsQueue.length) < 1000) {
+                        this.notificationsQueue.unshift();
+                    }
+                }
+            }
         }
-        if (sessionState.organization) {
-          event.originator.organization = {
-            id: sessionState.organization.id,
-            name: sessionState.organization.name,
-            department: sessionState.organization.department,
-            departmentName: sessionState.organization.departmentName
-          }
+    }
+    pushEvent(event, sessionState) {
+        const options = this.options();
+        if (options.inactive)
+            return;
+        if (this.stopped)
+            throw new Error('events queue has been stopped');
+        event.date = new Date().toISOString();
+        debug('pushEvent', event);
+        if (!event.originator && sessionState?.user && sessionState.account) {
+            if (sessionState.user.asAdmin) {
+                event.originator = {
+                    user: { ...sessionState.user.asAdmin, admin: true }
+                };
+            }
+            else if (sessionState.user.adminMode && (sessionState.account.type !== event.sender?.type || sessionState.account.id !== event.sender?.id)) {
+                event.originator = {
+                    user: { id: sessionState.user.id, name: sessionState.user.name, admin: true }
+                };
+            }
+            else {
+                event.originator = {
+                    user: { id: sessionState.user.id, name: sessionState.user.name }
+                };
+                if (sessionState.organization) {
+                    event.originator.organization = {
+                        id: sessionState.organization.id,
+                        name: sessionState.organization.name,
+                        department: sessionState.organization.department,
+                        departmentName: sessionState.organization.departmentName
+                    };
+                }
+            }
         }
-      }
+        this.eventsQueue.push(event);
+    }
+    pushNotification(notification) {
+        const options = this.options();
+        if (options.inactive)
+            return;
+        if (this.stopped)
+            throw new Error('notifications queue has been stopped');
+        notification.date = new Date().toISOString();
+        debug('pushNotification', notification);
+        this.notificationsQueue.push(notification);
     }
-    this.eventsQueue.push(event)
-  }
-
-  pushNotification (notification) {
-    const options = this.options()
-    if (options.inactive) { return }
-    if (this.stopped) { throw new Error('notifications queue has been stopped') }
-    notification.date = new Date().toISOString()
-    debug('pushNotification', notification)
-    this.notificationsQueue.push(notification)
-  }
 }
-const eventsQueue = new EventsQueue()
-export default eventsQueue
+const eventsQueue = new EventsQueue();
+export default eventsQueue;

package/http-agents.js

@@ -1,55 +1,55 @@
 // use better DNS lookup than nodejs default and try to reduce number of socket openings
-import CacheableLookup from 'cacheable-lookup'
-import HttpAgent, { HttpsAgent } from 'agentkeepalive'
-import { Counter, Gauge } from 'prom-client'
+import CacheableLookup from 'cacheable-lookup';
+import HttpAgent, { HttpsAgent } from 'agentkeepalive';
+import { Counter, Gauge } from 'prom-client';
 // not very high number of sockets but we don't want to saturate our reverse proxies
 // if a higher number is needed the service should probably be scaled anyway
 const keepaliveOpts = {
-  maxSockets: 8,
-  maxFreeSockets: 8,
-  timeout: 60000,
-  freeSocketTimeout: 30000
-}
-export const httpAgent = new HttpAgent(keepaliveOpts)
-export const httpsAgent = new HttpsAgent(keepaliveOpts)
-const cacheableLookup = new CacheableLookup()
-cacheableLookup.install(httpAgent)
-cacheableLookup.install(httpsAgent)
+    maxSockets: 8,
+    maxFreeSockets: 8,
+    timeout: 60000,
+    freeSocketTimeout: 30000
+};
+export const httpAgent = new HttpAgent(keepaliveOpts);
+export const httpsAgent = new HttpsAgent(keepaliveOpts);
+const cacheableLookup = new CacheableLookup();
+cacheableLookup.install(httpAgent);
+cacheableLookup.install(httpsAgent);
 // monitor agent statuses
-const agents = { http: httpAgent, https: httpsAgent }
+const agents = { http: httpAgent, https: httpsAgent };
 const socketsGauge = new Gauge({
-  name: 'df_http_agent_sockets',
-  help: 'Number of open sockets in the http agent',
-  labelNames: ['protocol', 'host']
-})
+    name: 'df_http_agent_sockets',
+    help: 'Number of open sockets in the http agent',
+    labelNames: ['protocol', 'host']
+});
 const freeSocketsGauge = new Gauge({
-  name: 'df_http_agent_free_sockets',
-  help: 'Number of free sockets in the http agent',
-  labelNames: ['protocol', 'host']
-})
+    name: 'df_http_agent_free_sockets',
+    help: 'Number of free sockets in the http agent',
+    labelNames: ['protocol', 'host']
+});
 const createSocketCounter = new Counter({
-  name: 'df_http_agent_create_socket_total',
-  help: 'Total number of sockets created by the http agent',
-  labelNames: ['protocol']
-})
+    name: 'df_http_agent_create_socket_total',
+    help: 'Total number of sockets created by the http agent',
+    labelNames: ['protocol']
+});
 const requestCounter = new Counter({
-  name: 'df_http_agent_request_total',
-  help: 'Total number of requests created by the http agent',
-  labelNames: ['protocol']
-})
+    name: 'df_http_agent_request_total',
+    help: 'Total number of requests created by the http agent',
+    labelNames: ['protocol']
+});
 setInterval(() => {
-  for (const _protocol of ['http', 'https']) {
-    const protocol = _protocol
-    const agentStatus = agents[protocol].getCurrentStatus()
-    for (const host in agentStatus.sockets) {
-      socketsGauge.set({ protocol, host }, agentStatus.sockets[host])
+    for (const _protocol of ['http', 'https']) {
+        const protocol = _protocol;
+        const agentStatus = agents[protocol].getCurrentStatus();
+        for (const host in agentStatus.sockets) {
+            socketsGauge.set({ protocol, host }, agentStatus.sockets[host]);
+        }
+        for (const host in agentStatus.freeSockets) {
+            freeSocketsGauge.set({ protocol, host }, agentStatus.freeSockets[host]);
+        }
+        createSocketCounter.remove({ protocol });
+        createSocketCounter.inc({ protocol }, agentStatus.createSocketCount);
+        requestCounter.remove({ protocol });
+        requestCounter.inc({ protocol }, agentStatus.requestCount);
     }
-    for (const host in agentStatus.freeSockets) {
-      freeSocketsGauge.set({ protocol, host }, agentStatus.freeSockets[host])
-    }
-    createSocketCounter.remove({ protocol })
-    createSocketCounter.inc({ protocol }, agentStatus.createSocketCount)
-    requestCounter.remove({ protocol })
-    requestCounter.inc({ protocol }, agentStatus.requestCount)
-  }
-}, 60000)
+}, 60000);