valence-connect

CNX Corporation

Clean Install

mkdir acme
cd acme
npm init --yes
npm install valence-connect --save

Starting the Node Server

Development

npm start

Debug

$ DEBUG=acme:* npm start

> set DEBUG=acme:* & npm start

PS > $env:DEBUG="acme:*" ; npm start

Production

npm run start:production

PS > npm run start:production_ps

Clustering

$ WEB_CONCURRENCY=3 npm run start:production

> set WEB_CONCURRENCY=3 & npm run start:production

PS > $env:WEB_CONCURRENCY="3" ; npm run start:production_ps

Examples

http://acme.com:7152/apps/customers/index.html

acme
│
└───bin
│       www.js
│
└───node_modules
│       valence-connect
│       *other modules
│
└───public
│   │
│   └───apps
│   │   │
│   │   └───customers "example"
│   │
│   └───images
│   │       valence_logo.png
│   │
│   └───stylesheets
│           style.css
│
└───routes
│   │   index.js
│   │   valence.js
│   │
│   └───api
│           customers.js "example"
│
└───services
│       Readme.md
│       customers.js "example"
│
└───tests
│       Readme.md
│       services.js "example"
│
└───views
│       error.pug
│       index.pug
│       layout.pug
│
│   .gitignore
│   app.js
│   package.json
│   Readme.md
│   valence.json

{
  "url": "http://acme.com:7052/service/connect?key=CD5678F68804D0123112TA0B8C93D1E58",
  "IBMi": true,
  "logging": false
}

routes/valence.js

/**
 * Valence Router
 */
const express        = require('express'),
      cors           = require('cors'),
      corsWhiteList  = ['http://acme.com:7052'],
      corsOptions    = {
          origin : (origin, callback) => {
              if (typeof origin === 'undefined'
                  || corsWhiteList.indexOf(origin) !== -1) {
                  callback(null, true);
              } else {
                  callback(new Error('Not allowed by CORS'));
              }
          }
      },
      router         = express.Router(),
      valenceConnect = require('valence-connect'),
      customers      = require(global.__services + 'customers/customers');

// Initialize Valence Connect
//
valenceConnect.init();

// Allow Cross Origin
//
router.all('*', cors(corsOptions));

/**
 * Check if the request session is authenticated
 * @param {IncomingMessage} req http request
 * @param {ServerResponse} res http response
 * @param {callback} next continue
*/
let valenceCheck = (req, res, next) => {
    valenceConnect.isAuthenticated(req, res)
        .then(() => {
            next();
        });
};

// Always check before proceeding that the session is valid for all Valence requests
//
router.use(valenceCheck);

// Routes
//

// Example Valence Route "query customers"
//
router.all('/customers/queryAll', customers.queryAll.bind(customers));

module.exports = router;

Tests

$ session=CURRENTSESSIONID npm test

> set session=CURRENTSESSIONID & npm test

PS > $env:session="CURRENTSESSIONID" ; npm test

Classes

ValenceConnect

Documentation: Security, session management, logging and utilities

Functions

getSessionStorage(key) ⇒ Promise.<>

get session storage

setSessionStorage(key, info) ⇒ Promise.<void>

set the session storage

ValenceConnect

• ValenceConnect

* [new ValenceConnect()](#new_ValenceConnect_new)
* [.baseInit()](#ValenceConnect+baseInit) ⇒ <code>Promise.<void></code>
* [.init([options])](#ValenceConnect+init) ⇒ <code>InitPromise</code>
* [.dbQuery(req, [res], statement)](#ValenceConnect+dbQuery) ⇒ <code>DbQueryPromise</code>
* [.decodeUTF16(inStr)](#ValenceConnect+decodeUTF16) ⇒ <code>string</code>
* [.getParams(req, [param])](#ValenceConnect+getParams) ⇒ <code>Object</code> \| <code>string</code> \| <code>number</code> \| <code>date</code> \| <code>array</code> \| <code>boolean</code> \| <code>\*</code>
* [.getSessionInformation(sid)](#ValenceConnect+getSessionInformation) ⇒ <code>SessionInformationPromise</code>
* [.getSettings(sid, [names], [cacheBuster])](#ValenceConnect+getSettings) ⇒ <code>SettingsPromise</code>
* [.getUserInformation(sid, [cacheBuster])](#ValenceConnect+getUserInformation) ⇒ <code>UserInformationPromise</code>
* [.isAuthenticated(req, res)](#ValenceConnect+isAuthenticated) ⇒ <code>IsAuthenticatedPromise</code>
* [.isEmpty(value)](#ValenceConnect+isEmpty) ⇒ <code>boolean</code>

new ValenceConnect()

const valenceConnect = require('valence-connect');

valenceConnect.baseInit() ⇒ Promise.<void>

valenceConnect.init(options) ⇒ InitPromise

// Using valence.json
//
valenceConnect.init();

// Passing options
//
valenceConnect.init({
    url     : 'http://acme.com:7052/service/connect?key=AZE678F68804D0123112TD0B8D93C1E38',
    IBMi    : true,
    logging : false,
});

valenceConnect.dbQuery(req, res, statement) ⇒ DbQueryPromise

router.all('/customers', (req, res) => {
    let statement     = 'select cusno as NUMBER, cname as NAME,' +
        ' ccity as CITY, cstate as STATE from DEMOCMAST',
        queryResponse = (response) => {
            res.json(response);
        },
        queryError    = (err) => {
            res.json(err);
        };

    valenceConnect.dbQuery(req, res, statement)
        .then(queryResponse)
        .catch(queryError);
});

valenceConnect.decodeUTF16(inStr) ⇒ string

let decodedValue = valenceConnect.decodeUTF16(encodedValue);

valenceConnect.getParams(req, param) ⇒ Object \| string \| number \| date \| array \| boolean \| \*

// All Parameters
// The variable params would be an object containing all the query string
//   and body parameters combined.
//
router.all('/processInventory', (req, res) => {
    let params = valenceConnect.getParams(req);

    if (params.inventoryId) {
      // process inventory
      //
    }
});

// Single Parameter
// The inventoryId variable would be a number since the front-end passed a numeric
//   value.
//
router.all('/processInventory', (req, res) => {
    let inventoryId = valenceConnect.getParams(req, 'inventoryId');

    if (inventoryId) {
      // process inventory
      //
    }
});

valenceConnect.getSessionInformation(sid) ⇒ SessionInformationPromise

router.all('/transferOrder', (req, res) => {
    let sessionId       = valenceConnect.getParams(req, 'sid'),
        sessionError    = (err) => {
            res.json(err);
        },
        sessionResponse = (info) => {
            if (info.envId === 1) {
                // process default
                //
            } else {
                //process other environment
                //
            }
        };

    valenceConnect.getSessionInformation(sessionId)
        .then(sessionResponse)
        .catch(sessionError);
});

valenceConnect.getSettings(sid, names, cacheBuster) ⇒ SettingsPromise

router.all('/settings', (req, res) => {
    let sessionId        = valenceConnect.getParams(req, 'sid'),
        settingsError    = (err) => {
            res.json(err);
        },
        settingsResponse = (settings) => {
            res.json({
                settings : settings
            });
        };

    valenceConnect.getSettings(sessionId)
        .then(settingsResponse)
        .catch(settingsError);
});

valenceConnect.getUserInformation(sid, cacheBuster) ⇒ UserInformationPromise

router.all('/userInformation', (req, res) => {
    let sessionId    = valenceConnect.getParams(req, 'sid'),
        userError    = (err) => {
            res.json(err);
        },
        userResponse = (info) => {
            res.json({
                user : info
            });
        };

    valenceConnect.getUserInformation(sessionId)
        .then(userResponse)
        .catch(userError);
});

valenceConnect.isAuthenticated(req, res) ⇒ IsAuthenticatedPromise

valenceConnect.isAuthenticated(req, res)
    .then(() => {
        // authenticated so continue...
        //
        next();
    });

valenceConnect.isEmpty(value) ⇒ boolean

if (valenceConnect.isEmpty(value)) {
    //value is empty
    //
} else {
    //value is not empty
    //
}

getSessionStorage(key) ⇒ Promise.<\*>

setSessionStorage(key, info) ⇒ Promise.<void>

Community

Versions

Prior to 1.1.1

• beta

1.1.1 - 2018-05-18

• General Availability

1.1.2 - 2018-09-12

• When calling getParams with a specific parameter value return null if not found instead of an empty object.

1.1.3 - 2018-12-27

• Update the required package url-parse minimum version to 1.4.3.

1.1.4 - 2020-12-21

• Update package dependencies to the latest ver
• Update core to handle dependency changes