uapi-json 1.17.6 → 1.19.0

package/README.md

@@ -89,6 +89,24 @@ It also has several useful helpers to handle errors.
 
 `logFunction` - set custom logging function that should match next shape `(...args) => {}`. Will receive all requests and responses from uapi/terminal.
 
+`httpsAgent` - set custom HTTPS agent for all requests created by the service. If the agent has `options.timeout`, that value is used as the request timeout.
+
+```javascript
+const https = require('https');
+
+const TerminalService = uAPI.createTerminalService({
+  auth,
+  options: {
+    httpsAgent: new https.Agent({
+      keepAlive: true,
+      maxSockets: 1,
+      maxFreeSockets: 1,
+      timeout: 90000,
+    }),
+  },
+});
+```
+
 ### Auth object
 <a name="auth"></a>
 

package/docs/Terminal.md

@@ -49,11 +49,12 @@ see [close_session](#close_session) method.
 # API
 
 **TerminalService**
-* [`.executeCommand(command, stopMD)`](#execute_command)
+* [`.executeCommand(command, options)`](#execute_command)
+* [`.executeStatelessCommandWhenIdle(command, options)`](#execute_stateless_command_when_idle)
 * [`.closeSession()`](#close_session)
 * [`.getToken()`](#get_token)
 
-## .executeCommand(command, stopMD)
+## .executeCommand(command, options)
 <a name="execute_command"></a>
 Executes a command in terminal and returns its terminal response
 
@@ -62,7 +63,61 @@ Executes a command in terminal and returns its terminal response
 | Param | Type | Description |
 | --- | --- | --- |
 | command | `String` | String representation of the command you want to execute |
+| options | `Object` | Optional command execution options. |
+
+**Options**
+
+| Param | Type | Description |
+| --- | --- | --- |
 | stopMD | `(screens) => boolean` | Function which gets all previous screens concatenated and detects if more `MD` command needed. |
+| sleepInterval | `Number` | Minimum delay in milliseconds from the last successful full terminal response to the next command send. |
+
+`stopMD` must be passed inside `options`; passing it directly as the second argument
+is not supported.
+
+## .executeStatelessCommandWhenIdle(command, options)
+<a name="execute_stateless_command_when_idle"></a>
+Executes a stateless command when terminal is idle and returns its terminal response.
+
+If terminal is busy, command is added to the stateless commands queue and executed
+after the current command and previously queued stateless commands are finished.
+Queued commands are executed one by one in FIFO order.
+If terminal is idle, regular `executeCommand` calls execute before queued stateless
+commands.
+
+This method is promise based. Every caller receives the result or error from its own
+command execution. If one queued command fails, later queued commands are still executed.
+If the active command fails before the queue is drained, queued stateless commands are
+skipped and rejected with the same terminal error.
+
+Stateless means command is independent of terminal context, such as an open booking,
+fare search, or other GDS working state. This method does not detect or enforce
+statelessness; caller is responsible for using it only for commands safe in any
+terminal context.
+
+**Returns**: `Promise` that returns terminal command response in `String` format
+
+| Param | Type | Description |
+| --- | --- | --- |
+| command | `String` | String representation of the stateless command you want to execute |
+| options | `Object` | Optional command execution options. |
+
+**Options**
+
+| Param | Type | Description |
+| --- | --- | --- |
+| stopMD | `(screens) => boolean` | Function which gets all previous screens concatenated and detects if more `MD` command needed. |
+| sleepInterval | `Number` | Minimum delay in milliseconds from the last successful full terminal response to the next command send. |
+
+```javascript
+await TerminalService.executeCommand('TE', {
+  stopMD: (screens) => screens.includes('END OF DISPLAY'),
+});
+
+await TerminalService.executeStatelessCommandWhenIdle('.CDIEV', {
+  sleepInterval: 1000,
+});
+```
 
 ## .closeSession()
 <a name="close_session"></a>

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "uapi-json",
-  "version": "1.17.6",
+  "version": "1.19.0",
   "description": "Travelport Universal API",
   "main": "src/",
+  "engines": {
+    "node": ">=20"
+  },
   "files": [
     "src/",
     "README.md",
@@ -27,36 +30,36 @@
     "node",
     "travelport"
   ],
-  "author": "Mark Orel <mail.ormark@gmail.com>",
   "contributors": [
-    "Dmytro Chertousov <d.chertousov@gmail.com>",
     "Artem Pylypchuk <articicejuice@gmail.com>",
-    "Yevhenii Huselietov <d46k16@gmail.com>",
+    "Dmytro Chertousov <d.chertousov@gmail.com>",
+    "Mark Orel <mail.ormark@gmail.com>",
     "Mark Omarov <dev.mark.omarov@gmail.com>",
-    "Oleksii Duvanov <colden.aid@gmail.com>"
+    "Oleksii Duvanov <colden.aid@gmail.com>",
+    "Yevhenii Huselietov <d46k16@gmail.com>"
   ],
   "license": "MIT",
   "dependencies": {
-    "axios": "^1.12.2",
+    "axios": "~1.15.0",
     "galileo-screen": "1.0.5",
-    "handlebars": "^4.7.8",
-    "handlebars-helper-equal": "^1.0.0",
-    "joi": "^18.0.1",
-    "moment": "^2.30.1",
-    "node-errors-helpers": "^1.0.0",
-    "pretty-data": "^0.40.0",
-    "promise-retry": "^2.0.1",
-    "xml2js": "^0.6.2"
+    "handlebars": "~4.7.9",
+    "handlebars-helper-equal": "~1.0.0",
+    "joi": "~18.1.2",
+    "moment": "~2.30.1",
+    "node-errors-helpers": "~1.0.0",
+    "pretty-data": "~0.40.0",
+    "promise-retry": "~2.0.1",
+    "xml2js": "~0.6.2"
   },
   "devDependencies": {
     "chai": "^4.5.0",
     "eslint": "^8.39.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-plugin-import": "^2.32.0",
-    "mocha": "^11.7.4",
+    "mocha": "^11.7.5",
     "nyc": "^17.1.0",
-    "proxyquire": "^2.1.3",
-    "readline2": "^1.0.1",
+    "proxyquire": "~2.1.3",
+    "readline2": "~1.0.1",
     "sinon": "^21.0.0",
     "sinon-chai": "^3.7.0"
   }

package/src/Request/uapi-parser.js

@@ -36,8 +36,9 @@ function mergeLeaf(item) {
   return { ...item, ...leaf };
 }
 
-function Parser(root, uapiVersion, env, debug, config, provider) {
+function Parser(root, uapiVersion, env, debug, config, provider, log) {
   this.debug = debug;
+  this.log = log || console.info;
   if (!config) {
     this.config = defaultConfig(uapiVersion);
   } else {
@@ -212,7 +213,7 @@ Parser.prototype.parse = function (xml) {
 
       const end = new Date() - start;
       if (this.debug > 1) {
-        console.info('uAPI_Parse execution time: %dms', end);
+        this.log('uAPI_Parse execution time: %dms', end);
       }
 
       return data[self.rootObject];

package/src/Request/uapi-request.js

@@ -1,5 +1,6 @@
 const handlebars = require('handlebars');
 const axios = require('axios');
+const https = require('https');
 const { pd } = require('pretty-data');
 const {
   RequestValidationError,
@@ -13,6 +14,14 @@ const configInit = require('../config');
 
 handlebars.registerHelper('equal', require('handlebars-helper-equal'));
 
+const REQUEST_AGENT_OPTIONS = {
+  keepAlive: true,
+  keepAliveMsecs: 5000,
+  maxSockets: 20,
+  maxFreeSockets: 20,
+};
+const httpsAgent = new https.Agent(REQUEST_AGENT_OPTIONS);
+
 /**
  * basic function for requests/responses
  * @param  {string} service          service url for current response (gateway)
@@ -43,6 +52,15 @@ module.exports = function uapiRequest(
 
   const config = configInit(auth.region);
   const log = options.logFunction || console.log;
+  const customHttpsAgent = options.httpsAgent;
+  const requestHttpsAgent = customHttpsAgent || httpsAgent;
+  const requestTimeout = (
+    customHttpsAgent
+    && customHttpsAgent.options
+    && typeof customHttpsAgent.options.timeout === 'number'
+  )
+    ? customHttpsAgent.options.timeout
+    : config.timeout || 5000;
 
   // Performing checks
   if (!service || service.length <= 0) {
@@ -64,7 +82,7 @@ module.exports = function uapiRequest(
     }
 
     // create a v52 uAPI parser with default params and request data in env
-    const uParser = new Parser(rootObject, 'v52_0', params, debugMode, null, auth.provider);
+    const uParser = new Parser(rootObject, 'v52_0', params, debugMode, null, auth.provider, log);
 
     const validateInput = () => (
       Promise.resolve(params)
@@ -85,7 +103,8 @@ module.exports = function uapiRequest(
         const response = await axios.request({
           url: service,
           method: 'POST',
-          timeout: config.timeout || 5000,
+          timeout: requestTimeout,
+          httpsAgent: requestHttpsAgent,
           auth: {
             username: auth.username,
             password: auth.password,
@@ -156,7 +175,6 @@ module.exports = function uapiRequest(
     };
 
     const validateSOAP = function (parsedXML) {
-      console.log(parsedXML);
       if (parsedXML['SOAP:Fault']) {
         if (debugMode > 2) {
           log('Parsed error response', pd.json(parsedXML));
@@ -169,7 +187,8 @@ module.exports = function uapiRequest(
           params,
           debugMode,
           errParserConfig,
-          auth.provider
+          auth.provider,
+          log
         );
         const errData = errParser.mergeLeafRecursive(parsedXML['SOAP:Fault'][0]); // parse error data
         return errorHandler.call(errParser, errData);

package/src/Services/Air/AirFormat.js

@@ -197,7 +197,7 @@ function formatPassengerCategories(pricingInfo) {
 
         [code] = list;
         if (!list[0] || list.length !== 1) { // TODO throw error
-          console.log('Warning: different categories '
+          console.warn('Warning: different categories '
             + list.join() + ' in single fare calculation ' + key + ' in fare ' + key);
         }
         passengerCounts[code] = count;

package/src/Services/Air/AirParser.js

@@ -218,7 +218,7 @@ function airPrice(obj) {
 
   let pricingSolution = 0;
   if (priceKeys.length > 1) {
-    console.log('More than one solution found in booking. Resolving the cheapest one.');
+    console.warn('More than one solution found in booking. Resolving the cheapest one.');
     const solutions = priceKeys.map((key) => pricingSolutions[key]);
 
     [pricingSolution] = solutions.sort(
@@ -347,7 +347,7 @@ function airPriceRspPricingSolutionXML(obj) {
   let pricingSolution = 0;
   if (pricingSolutions.length > 1) {
     // TODO: Check result for multiple passenger type results.
-    console.log('More than one solution found in booking. Resolving the cheapest one.');
+    console.warn('More than one solution found in booking. Resolving the cheapest one.');
     [pricingSolution] = pricingSolutions.sort(
       (a, b) => parseFloat(a.$.TotalPrice.slice(3)) - parseFloat(b.$.TotalPrice.slice(3))
     );

package/src/Services/Terminal/Terminal.js

@@ -101,6 +101,17 @@ const isErrorRetriable = (e) => {
   return (errorCode && RETRY_CODES_LIST.includes(errorCode));
 };
 
+const defaultStopMD = (screens) => !screenFunctions.hasMore(screens);
+
+const getCommandOptions = (options = {}) => ({
+  stopMD: options.stopMD || defaultStopMD,
+  sleepInterval: options.sleepInterval || 0,
+});
+
+const wait = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+
 module.exports = function (settings) {
   const {
     timeout = false, debug = 0, autoClose = true,
@@ -109,25 +120,37 @@ module.exports = function (settings) {
   } = settings;
 
   const service = terminalService(validateServiceSettings(settings));
-  const defaultStopMD = (screens) => !screenFunctions.hasMore(screens);
 
   const state = {
     terminalState: TERMINAL_STATE_NONE,
     sessionToken: token,
+    terminalError: null,
+    lastCommandFinishedAt: null,
+    statelessCommandsQueue: [],
   };
 
   // Getting session token
-  const getSessionToken = async () => {
-    // Return error if not in correct state
+  const throwIfTerminalUnavailable = () => {
     if (state.terminalState === TERMINAL_STATE_BUSY) {
       throw new TerminalRuntimeError.TerminalIsBusy();
     }
     if (state.terminalState === TERMINAL_STATE_CLOSED) {
       throw new TerminalRuntimeError.TerminalIsClosed();
     }
+    if (state.terminalState === TERMINAL_STATE_ERROR) {
+      throw state.terminalError;
+    }
+  };
 
-    state.terminalState = TERMINAL_STATE_BUSY;
+  const setTerminalBusy = () => {
+    throwIfTerminalUnavailable();
+    Object.assign(state, {
+      terminalState: TERMINAL_STATE_BUSY,
+      terminalError: null,
+    });
+  };
 
+  const getSessionToken = async () => {
     // Return token if already obtained
     if (state.sessionToken !== null) {
       return state.sessionToken;
@@ -137,7 +160,6 @@ module.exports = function (settings) {
     state.sessionToken = sessionToken;
 
     if (!emulatePcc) {
-      state.terminalState = TERMINAL_STATE_READY;
       return state.sessionToken;
     }
 
@@ -158,6 +180,8 @@ module.exports = function (settings) {
       throw new TerminalRuntimeError.TerminalEmulationFailed(response);
     }
 
+    state.lastCommandFinishedAt = Date.now();
+
     return sessionToken;
   };
 
@@ -207,63 +231,197 @@ module.exports = function (settings) {
 
   // Get terminal ID
   const getTerminalId = (sessionToken) => getHashSubstr(sessionToken);
+  const isClosed = () => state.terminalState === TERMINAL_STATE_CLOSED;
+  const isInitialized = () => state.terminalState !== TERMINAL_STATE_NONE;
+  const hasStatelessCommands = () => (
+    state.statelessCommandsQueue.length > 0
+  );
+  const setTerminalReady = () => {
+    Object.assign(state, {
+      terminalState: TERMINAL_STATE_READY,
+      terminalError: null,
+    });
+  };
+  const setTerminalError = (err) => {
+    Object.assign(state, {
+      terminalState: TERMINAL_STATE_ERROR,
+      terminalError: err,
+    });
+  };
+  const rejectStatelessCommandsQueue = (err) => {
+    while (state.statelessCommandsQueue.length > 0) {
+      const { reject } = state.statelessCommandsQueue.shift();
+      reject(err);
+    }
+  };
+  const sleepBeforeCommand = async (sleepInterval) => {
+    if (state.lastCommandFinishedAt === null || sleepInterval <= 0) {
+      return;
+    }
 
-  const terminal = {
-    getToken: async () => {
-      await getSessionToken();
-      // Needed here as getSessionToken marks terminal as busy
-      state.terminalState = TERMINAL_STATE_READY;
-      return state.sessionToken;
-    },
-    executeCommand: async (command, stopMD = defaultStopMD) => {
-      try {
-        const sessionToken = await getSessionToken();
-        const terminalId = getTerminalId(sessionToken);
+    const timeToWait = sleepInterval - (Date.now() - state.lastCommandFinishedAt);
 
-        if (debug) {
-          log(`[${terminalId}] Terminal request:\n${command}`);
-        }
+    if (timeToWait > 0) {
+      await wait(timeToWait);
+    }
+  };
+  const executeCommandInternal = async (command, options) => {
+    const { stopMD, sleepInterval } = options;
+    const sessionToken = await getSessionToken();
+    const terminalId = getTerminalId(sessionToken);
 
-        const screen = await executeCommandWithRetry(command);
-        const response = await processResponse(screen, stopMD);
+    await sleepBeforeCommand(sleepInterval);
 
-        if (debug) {
-          log(`[${terminalId}] Terminal response:\n${response}`);
-        }
+    if (debug) {
+      log(`[${terminalId}] Terminal request:\n${command}`);
+    }
 
-        Object.assign(state, {
-          terminalState: TERMINAL_STATE_READY,
-        });
+    const screen = await executeCommandWithRetry(command);
+    const response = await processResponse(screen, stopMD);
 
-        if (UNEXPECTED_TERMINAL_ERRORS.some((e) => response.includes(e))) {
-          const errorObject = isFinancialCommand(command)
-            ? new TerminalRuntimeError.TerminalUnexpectedFinancialError({ screen: response })
-            : new TerminalRuntimeError.TerminalUnexpectedError({ screen: response });
+    if (debug) {
+      log(`[${terminalId}] Terminal response:\n${response}`);
+    }
 
-          throw errorObject;
-        }
+    if (UNEXPECTED_TERMINAL_ERRORS.some((e) => response.includes(e))) {
+      const errorObject = isFinancialCommand(command)
+        ? new TerminalRuntimeError.TerminalUnexpectedFinancialError({ screen: response })
+        : new TerminalRuntimeError.TerminalUnexpectedError({ screen: response });
+
+      throw errorObject;
+    }
+
+    state.lastCommandFinishedAt = Date.now();
+
+    return response;
+  };
+  const drainStatelessCommandsQueue = async () => {
+    if (state.statelessCommandsQueue.length === 0) {
+      setTerminalReady();
+      return;
+    }
+
+    const {
+      command, options, resolve, reject,
+    } = state.statelessCommandsQueue.shift();
+
+    try {
+      const response = await executeCommandInternal(command, options);
+
+      if (!hasStatelessCommands()) {
+        setTerminalReady();
+      }
+      resolve(response);
+    } catch (err) {
+      if (!hasStatelessCommands()) {
+        setTerminalReady();
+      }
+      reject(err);
+    }
 
-        return response;
+    await drainStatelessCommandsQueue();
+  };
+  const executeAndDrainCommands = async (command, options) => {
+    try {
+      const response = await executeCommandInternal(command, options);
+
+      if (hasStatelessCommands()) {
+        drainStatelessCommandsQueue()
+          .then(setTerminalReady)
+          .catch(setTerminalError);
+      } else {
+        setTerminalReady();
+      }
+
+      return response;
+    } catch (err) {
+      setTerminalError(err);
+      rejectStatelessCommandsQueue(err);
+      throw err;
+    }
+  };
+
+  const terminal = {
+    getToken: async () => {
+      setTerminalBusy();
+
+      try {
+        await getSessionToken();
+        setTerminalReady();
+        return state.sessionToken;
       } catch (err) {
-        Object.assign(state, {
-          terminalState: TERMINAL_STATE_ERROR,
-        });
+        setTerminalError(err);
         throw err;
       }
     },
-    closeSession: () => getSessionToken()
-      .then(
-        (sessionToken) => service.closeSession({
-          sessionToken,
-        })
-      ).then(
-        (response) => {
-          Object.assign(state, {
-            terminalState: TERMINAL_STATE_CLOSED,
+    executeCommand: async (command, options) => {
+      setTerminalBusy();
+      return executeAndDrainCommands(command, getCommandOptions(options));
+    },
+    executeStatelessCommandWhenIdle: async (command, options) => {
+      const commandOptions = getCommandOptions(options);
+
+      if (state.terminalState === TERMINAL_STATE_CLOSED) {
+        throw new TerminalRuntimeError.TerminalIsClosed();
+      }
+      if (state.terminalState === TERMINAL_STATE_ERROR) {
+        throw state.terminalError;
+      }
+      if (state.terminalState === TERMINAL_STATE_BUSY || hasStatelessCommands()) {
+        return new Promise((resolve, reject) => {
+          state.statelessCommandsQueue.push({
+            command, options: commandOptions, resolve, reject,
           });
-          return response;
-        }
-      ),
+        });
+      }
+
+      setTerminalBusy();
+      return executeAndDrainCommands(command, commandOptions);
+    },
+    isClosed,
+    isInitialized,
+    closeSessionSafe: async () => {
+      if (isClosed()) {
+        console.warn('UAPI-JSON WARNING: Terminal session is already closed');
+        return;
+      }
+      if (!isInitialized()) {
+        console.warn('UAPI-JSON WARNING: Terminal session is not initialized');
+        return;
+      }
+
+      await terminal.closeSession().catch(console.error);
+    },
+    closeSession: () => {
+      if (state.terminalState === TERMINAL_STATE_BUSY) {
+        return Promise.reject(new TerminalRuntimeError.TerminalIsBusy());
+      }
+      if (state.terminalState === TERMINAL_STATE_CLOSED) {
+        return Promise.reject(new TerminalRuntimeError.TerminalIsClosed());
+      }
+      if (state.terminalState === TERMINAL_STATE_ERROR && state.sessionToken === null) {
+        return Promise.reject(state.terminalError);
+      }
+
+      Object.assign(state, {
+        terminalState: TERMINAL_STATE_BUSY,
+      });
+
+      return getSessionToken()
+        .then(
+          (sessionToken) => service.closeSession({
+            sessionToken,
+          })
+        ).then(
+          (response) => {
+            Object.assign(state, {
+              terminalState: TERMINAL_STATE_CLOSED,
+              terminalError: null,
+            });
+            return response;
+          }
+        );
+    },
   };
 
   if (autoClose) {