impossiblefxv1 1.13.2

package/dist-tools/foo.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+echo "S3: updating to version: ${npm_package_version}"
+

package/dist-tools/publish.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+echo "S3: updating to version: ${npm_package_version}"
+
+aws s3 cp --acl public-read dist/fx-sdk-latest.js s3://is-exchange/sdk/fx-sdk-latest.js
+aws s3 cp --acl public-read dist/fx-sdk-latest.js s3://is-exchange/sdk/fx-sdk-${npm_package_version}.js

package/lib/browser.js

@@ -0,0 +1,58 @@
+var FX = require('./core')
+var path = require('path')
+
+// Load browser API loader
+FX.apiLoader = function(svc, version) {
+  return FX.apiLoader.services[svc][version];
+};
+
+require('./credentials/token');
+require('protobufjs');
+require('bytebuffer');
+
+FX.CredentialProviderChain.defaultProviders = [
+  function () { return new FX.TokenCredentials(); },
+];
+
+
+FX.util.update(FX.Config.prototype.keys, {
+    credentials: function () {
+        var credentials = null;
+        new FX.CredentialProviderChain([
+            function () { return new FX.TokenCredentials(); },
+        ]).resolve(function(err, creds) {
+            if(!err)
+                credentials = creds;
+        });
+
+        return credentials;
+    },
+
+    credentialProvider: function() {
+        return FX.CredentialProviderChain();
+    },
+});
+
+
+
+
+// Reset configuration
+FX.config = new FX.Config();
+
+
+/**
+ * @api private
+ */
+FX.apiLoader.services = {};
+
+
+// Marker for browser-builder
+// DO NOT DELETE
+// $$$ IFX $$$
+
+// Load the XHR HttpClient
+require('./http/xhr');
+
+if(typeof window !== 'undefined') window.FX = FX;
+if(typeof module !== 'undefined') module.exports = FX;
+if(typeof self !== 'undefined') self.FX = FX;

package/lib/config.js

@@ -0,0 +1,125 @@
+var FX = require('./core');
+require('./credentials');
+require('./credentials/chain');
+
+FX.Config = FX.util.inherit({
+
+    // @option options apikey [String]
+    // @option options apisecret [String]
+    // @option options region [String] the region to send service requests to.
+
+    constructor: function Config(options) {
+        if (options === undefined) {
+            options = {}; 
+        } 
+
+        FX.util.each.call(this, this.keys, function (key, value) {
+            this.set(key, options[key], value);
+        });
+
+    },
+
+    update: function update(options, allowUnknownKeys) {
+        allowUnknownKeys = allowUnknownKeys || false;
+        options = this.extractCredentials(options);
+        FX.util.each.call(this, options, function (key, value) {
+            if (allowUnknownKeys || Object.prototype.hasOwnProperty.call(this.keys, key) ) {
+                this.set(key, value);
+            }
+        });
+    },
+
+    set: function set(property, value, defaultValue) {
+        if (value === undefined) {
+            if (defaultValue === undefined) {
+                defaultValue = this.keys[property];
+            }
+            if (
+                typeof defaultValue === 'function') {
+                this[property] = defaultValue.call(this);
+            } else {
+                this[property] = defaultValue;
+            }
+        } else {
+            this[property] = value;
+        }
+    },
+
+    //callback is a function(err, credentials)
+    getCredentials: function getCredentials(callback) {
+        var self = this;
+
+        function finish(err) {
+            callback(err, err ? null : self.credentials);
+        }
+
+        function getAsyncCredentials() {
+            self.credentials.get(function(err) {
+                finish(err);
+            });
+        }
+
+        function getStaticCredentials() {
+            var err = null;
+            if (!self.credentials.apikey || !self.credentials.apisecret) {
+                err =  new Error('Missing credentials');
+            }
+            finish(err);
+        }
+
+        if(self.apikey && self.apisecret && !self.credentials) {
+            self.credentials = new FX.Credentials(self) 
+        }
+
+        if (self.credentials) {
+            if (typeof self.credentials.get === 'function') {
+                getAsyncCredentials();
+            } else { 
+                getStaticCredentials();
+            }
+        } else if (self.credentialProvider) {
+            self.credentialProvider.resolve(function(err, creds) {
+                self.credentials = creds;
+                finish(err);
+            });
+            
+        } else {
+            finish(new Error('No credentials to load'));
+        }
+    },
+
+
+    extractCredentials: function(options) {
+        if(options.apikey && options.apisecret) {
+            options = FX.util.copy(options)
+            options.credentials = new FX.Credentials(options) 
+        } 
+        return options;        
+    },
+
+
+    keys: {
+        apikey: null,
+        apisecret: null,
+        credentials: null,
+        credentialProvider: null,
+        region: null,
+        domainSuffix: ".impossible.io",
+        apiVersion: 'latest',
+        apiVersions: {},
+        protocol: 'https',
+        responseTimeout: 600000,
+        promiseDependency: null,
+        logger: null,
+        retryDelayBase: 100,
+        maxRetries: 10,
+        requiresAuth: true,
+        SDL: {
+            populateDefaults: false,
+            url: null,    
+            domain: "JetSDL.Proto"
+        },
+    }
+})
+
+FX.config = new FX.Config();

package/lib/core.js

@@ -0,0 +1,15 @@
+var path = require('path');
+
+var FX = { util: require('./util') }
+
+module.exports = FX;
+
+require('./config')
+
+require('./http');
+require('./service');
+require('./proto');
+require('./encoding');
+require('./protocol');
+require('./request');
+require('./response');

package/lib/credentials/chain.js

@@ -0,0 +1,54 @@
+var FX = require('../core');
+
+FX.CredentialProviderChain = FX.util.inherit(FX.Credentials, {
+
+  /**
+   * Creates a new CredentialProviderChain with a default set of providers
+   * specified by {defaultProviders}.
+   */
+  constructor: function CredentialProviderChain(providers) {
+    if (providers) {
+      this.providers = providers;
+    } else {
+      this.providers = FX.CredentialProviderChain.defaultProviders.slice(0);
+    }
+  },
+
+  resolve: function resolve(callback) {
+    if (this.providers.length === 0) {
+      callback(new Error('No providers'));
+      return this;
+    }
+
+    var index = 0;
+    var providers = this.providers.slice(0);
+
+    function resolveNext(err, creds) {
+      if ((!err && creds) || index === providers.length) {
+        callback(err, creds);
+        return;
+      }
+
+      var provider = providers[index++];
+      if (typeof provider === 'function') {
+        creds = provider.call();
+      } else {
+        creds = provider;
+      }
+
+      if (creds.get) {
+        creds.get(function(getErr) {
+          resolveNext(getErr, getErr ? null : creds);
+        });
+      } else {
+        resolveNext(null, creds);
+      }
+    }
+
+    resolveNext();
+    return this;
+  }
+
+});
+
+FX.CredentialProviderChain.defaultProviders = [];

package/lib/credentials/environment.js

@@ -0,0 +1,69 @@
+var FX = require('../core');
+
+/**
+ * Represents credentials from the environment.
+ *
+*/
+FX.EnvironmentCredentials = FX.util.inherit(FX.Credentials, {
+
+  /**
+   * Creates a new EnvironmentCredentials class with a given variable
+   * prefix {envPrefix}. For example, to load credentials using the 'FX'
+   * prefix:
+   *
+   * ```javascript
+   * var creds = new FX.EnvironmentCredentials('FX');
+   * creds.accessKeyId == 'AKID' // from FX_ACCESS_KEY_ID env var
+   * ```
+   *
+   * @param envPrefix [String] the prefix to use (e.g., 'FX') for environment
+   *   variables. Do not include the separating underscore.
+   */
+    constructor: function EnvironmentCredentials(envPrefix) {
+        FX.Credentials.call(this);
+        this.get(function() {});
+    },
+
+  /**
+   * Loads credentials from the environment using the prefixed
+   * environment variables.
+   *
+   * @callback callback function(err)
+   *   Called after the (prefixed) APIKEY, APISECRET environment variables are read. When this callback is
+   *   called with no error, it means that the credentials information has
+   *   been loaded into the object (as the `accessKeyId`, `secretAccessKey`,
+   *   and `sessionToken` properties).
+   *   @param err [Error] if an error occurred, this value will be filled
+   * @see get
+   */
+  refresh: function refresh(callback) {
+    if (!callback) callback = function(err) { if (err) throw err; };
+
+    if (!process || !process.env) {
+      callback(
+        new Error('No process info or environment variables available')
+      );
+      return;
+    }
+
+    var keys = ['APIKEY', 'APISECRET'];
+    var values = [];
+
+    for (var i = 0; i < keys.length; i++) {
+      var prefix = '';
+      if (this.envPrefix) prefix = this.envPrefix + '_';
+      values[i] = process.env[prefix + keys[i]];
+      if (!values[i]) {
+        callback(
+          new Error('Variable ' + prefix + keys[i] + ' not set.')
+        );
+        return;
+      }
+    }
+
+    this.expired = false;
+    FX.Credentials.apply(this, values);
+    callback();
+  }
+
+});

package/lib/credentials/inifile.js

@@ -0,0 +1,57 @@
+var FX = require('../core');
+var path = require('path');
+
+
+FX.IniFileCredentials = FX.util.inherit(FX.Credentials, {
+  constructor: function IniFileCredentials(options) {
+    FX.Credentials.call(this);
+
+    options = options || {};
+
+    this.filename = options.filename;
+    this.profile = options.profile || process.env.FX_PROFILE || 'default';
+    this.get(function() {});
+  },
+
+  refresh: function refresh(callback) {
+    if (!callback) callback = function(err) { if (err) throw err; };
+    try {
+      if (!this.filename)
+        this.loadDefaultFilename();
+      var creds = FX.util.ini.parse(FX.util.readFileSync(this.filename));
+      var profile = creds[this.profile];
+
+      if (typeof profile !== 'object') {
+        throw new Error('Profile ' + this.profile + ' not found in ' + this.filename)
+      }
+
+
+      this.apikey = profile['apikey'];
+      this.apisecret = profile['apisecret'];
+
+      if (!this.apikey || !this.apisecret) {
+        throw new Error('Credentials not set in ' + this.filename +
+                    ' using profile ' + this.profile)
+      }
+      this.expired = false;
+      callback();
+    } catch (err) {
+      callback(err);
+    }
+  },
+
+  /**
+   * @api private
+   */
+  loadDefaultFilename: function loadDefaultFilename() {
+    var env = process.env;
+    var home = env.HOME ||
+               env.USERPROFILE ||
+               (env.HOMEPATH ? ((env.HOMEDRIVE || 'C:/') + env.HOMEPATH) : null);
+    if (!home) {
+      throw new Error('Cannot load credentials, HOME path not set')
+    }
+
+    this.filename = path.join(home, '.fx', 'credentials');
+  }
+});

package/lib/credentials/token.js

@@ -0,0 +1,38 @@
+var FX = require('../core');
+
+/**
+ * Represents credentials from the browser session.
+ * Reads the OAuth2 access token from sessionStorage (set by the web console auth service).
+ */
+FX.TokenCredentials = FX.util.inherit(FX.Credentials, {
+  constructor: function TokenCredentials(options) {
+
+    FX.Credentials.call(this);
+
+    options = options || {};
+
+    this.get(function() {});
+  },
+
+  refresh: function refresh(callback) {
+    if (!callback)
+        callback = function(err) { if (err) throw err; };
+
+    try {
+        var token = sessionStorage.getItem('access_token');
+        if(!token)
+            throw new Error("No access token available in sessionStorage")
+
+        this.apitoken = token;
+        this.expired = false;
+        callback();
+
+    } catch (err) {
+
+      callback(err);
+
+    }
+
+  }
+})
+

package/lib/credentials.js

@@ -0,0 +1,53 @@
+var FX = require('./core')
+var inherit = FX.util.inherit
+
+FX.Credentials = inherit({
+    constructor: function Credentials() {
+        this.expired = false;
+        this.expireTime = null;
+
+        if(arguments.length === 1 && typeof arguments[0] === 'object') {
+            var creds = arguments[0].credentials || arguments[0];
+            this.apikey = creds.apikey;
+            this.apisecret = creds.apisecret;
+        } else {
+            this.apikey = arguments[0];
+            this.apisecret = arguments[1];
+        }
+    },
+
+    expiryWindow: 60,
+
+    needsRefresh: function needsRefresh() {
+        var currentTime = new Date().getTime();
+        var adjustedTime = new Date(currentTime + this.expiryWindow * 1000);
+
+        if(this.expireTime && adjustedTime > this.expireTime) {
+            return true;
+        } else {
+            return this.expired || !this.apikey || !this.apisecret;
+        }
+    },
+
+    get: function get(callback) {
+        var self = this;
+        if(this.needsRefresh()) {
+            this.refresh(function(err) {
+                if(!err) 
+                    self.expired = false; // reset expired flag
+                if(callback)
+                    callback(err);
+            });
+        } else if(callback) {
+            callback();
+        }
+    },
+
+    refresh: function refresh(callback) {
+        this.expired = false;
+        callback();
+    }
+})
+
+
+

package/lib/encoding.js

@@ -0,0 +1,36 @@
+var FX = require('./core')
+var inherit = FX.util.inherit
+
+FX.Encoding = {
+
+    json: {
+        encode: function(obj) {
+            return JSON.stringify(obj)
+        },
+
+        decode: function(data) {
+            return JSON.parse(data)
+        }
+    },
+
+    binary: {
+        decode: function(data) {
+            return data
+        },
+        
+        encode: function(obj) {
+            return obj
+        }
+    },
+
+    protobuf: {
+        decode: function(messagetype, data) {
+            return messagetype.decode(data)
+        },
+        
+        encode: function(obj) {
+            return obj.toArrayBuffer()
+        }
+    }
+
+}

package/lib/endpoint.js

@@ -0,0 +1,18 @@
+
+function configureEndpoint(svc){
+    var endpoint = null;
+
+    if(svc.api.endpoint && svc.config.region){
+        endpoint = svc.api.endpoint.replace(/\{region\}/g, svc.config.region);
+    } else if(svc.api.globalEndpoint){
+        endpoint = svc.api.globalEndpoint;  
+    }
+    
+    if(endpoint){
+        endpoint = endpoint.replace(/\{domainSuffix\}/g, svc.config.domainSuffix);
+    }
+        
+    svc.config.endpoint = endpoint
+}
+
+module.exports = configureEndpoint

package/lib/fx.js

@@ -0,0 +1,50 @@
+var FX = require('./core')
+module.exports = FX;
+
+// Load Node HTTP client
+require('./http/node');
+
+// Load all service classes
+require('./services');
+
+require('./credentials/inifile');
+require('./credentials/environment');
+require('./credentials/token');
+
+FX.CredentialProviderChain.defaultProviders = [
+  function () { return new FX.EnvironmentCredentials('FX'); },
+  function () { return new FX.IniFileCredentials({filename: 'fx.credentials'}); },
+  function () { return new FX.IniFileCredentials(); },
+];
+
+// Update configuration keys
+FX.util.update(FX.Config.prototype.keys, {
+    credentials: function () {
+        var credentials = null;
+        new FX.CredentialProviderChain([
+            function () { return new FX.EnvironmentCredentials('FX'); },
+            function () { return new FX.IniFileCredentials({filename: 'fx.credentials'}); },
+            function () { return new FX.IniFileCredentials(); },
+        ]).resolve(function(err, creds) {
+            if(!err)
+                credentials = creds;
+        });
+
+        return credentials;
+    },
+
+    credentialProvider: function() {
+        return FX.CredentialProviderChain();
+    },
+
+    region: function() {
+        return process.env.FX_REGION;
+    }
+});
+
+
+
+
+// Reset configuration
+FX.config = new FX.Config();
+

package/lib/http/node.js

@@ -0,0 +1,69 @@
+var FX = require('../core');
+
+var Stream = require('stream').Stream;
+
+require('../http');
+
+
+FX.NodeHttpClient = FX.util.inherit({
+    exec: function(request, callback) {
+        request.authenticate(function(err) {
+
+            if(err) {
+
+                callback(err, null)
+
+            } else {
+                var fr = require("follow-redirects")
+                var http = request.protocol == "https" ? fr.https : fr.http
+                
+                if(request.hostname.startsWith("render")){
+                    http = request.protocol == "https" ? require("https")  : require(http);
+                }
+
+                var options = {
+                    hostname: request.hostname,
+                    path: request.path,
+                    method: request.method,
+                    port: request.port,
+                    auth: request.auth,
+                    headers: request.headers,
+                }
+
+                var stream = http.request(options)
+                var body = request.data;
+
+                if(request.timeout) {
+                    stream.setTimeout(request.timeout, function() {
+                        stream.abort();
+                    })
+                }
+                
+                if(body) {
+                    if(body instanceof Stream) {
+                        request.data.pipe(stream)
+                    } else if(body instanceof Uint8Array) {
+                        var buffer = new Buffer(body.buffer)
+                        stream.end(buffer)     
+                    } else if(body instanceof ArrayBuffer) {
+                        var buffer = new Buffer(body)
+                        stream.end(buffer)     
+                        
+                    } else {
+                        stream.end(body)
+                    }
+                } else {
+                    stream.end();
+                }
+
+               /* stream.on("response", function(response){
+                    console.log("response", response);
+                })*/
+
+                callback(null, stream)
+            }
+        })
+    }
+})
+
+FX.HttpClient.prototype = FX.NodeHttpClient.prototype;

package/lib/http/xhr.js

@@ -0,0 +1,12 @@
+var FX = require('../core');
+
+var Stream = require('stream').Stream;
+
+require('../http');
+require('./node');
+
+FX.XhrHttpClient = FX.util.inherit({
+    // no implementation
+})
+
+FX.HttpClient.prototype = FX.NodeHttpClient.prototype;