@kumologica/sdk 3.0.0

package/src/app/lib/stores/settings-network-store.spec.js

@@ -0,0 +1,27 @@
+
+const chai = require('chai');
+const { NetworkConfigStore } = require('./settings-network-store');
+let expect = chai.expect;
+let assert = chai.assert;
+
+describe('parse correctly a settings config file', () => {
+    it('happy path', () => {
+      let store = new NetworkConfigStore();
+      
+      // console.log(store.getProxyDetails());
+      // store.saveProxyDetails('http://example.com', 8080 );
+      // console.log(store.getProxyDetails());
+      // console.log(store.getAWSAliases())
+    //   let defaultObj = store.getKumohubAliasInfo('default');
+
+    //   assert.equal(defaultObj.username, 'your-username');
+    //   assert.equal(defaultObj.password, 'your-password');
+    //   assert.equal(defaultObj.subscription, 'kumohub-subscription-id');
+
+
+    //   store.writeCloudConfigFile(`[{{{}asdjf;lj }}} [[[]]another-example\nusername = javier`)
+
+    //   expect(props.queryParams).to.eql({ name: 'me' });
+
+    });
+  });

package/src/app/lib/stores/store.js

@@ -0,0 +1,97 @@
+const electron = require('electron');
+const path = require('path');
+const fs = require('fs-extra');
+/**
+ * This is an abstract Store. You should extend it.
+ */
+class Store {
+  /**
+   * @typedef {Object} StoreProps
+   * @property {String} configName - configuration file name (without .json suffix)
+   * @property {Object}[defaults={}] - defaults properties
+   */
+  /**
+   * @param {StoreProps} props
+   */
+  constructor(props) {
+    // We'll use the `configName` property to set the file name and 
+    // path.join to bring it all together as a string
+    if (props.dataPath) {
+      this.path = props.dataPath;
+    } else {
+      // Renderer process has to get `app` module via `remote`, 
+      // whereas the main process can get it directly
+      // app.getPath('userData') will return a string of the 
+      // user's app data directory path.
+      this.userDataPath = (electron.app || electron.remote.app).getPath(
+        'userData'
+      );
+      this.path = this.userDataPath;
+    }
+    this.path = path.join(this.path, props.configName + '.json');
+    this.data = parseDataFile(this.path, props.defaults);
+  }
+
+  getUserDataPath() {
+    return this.userDataPath;
+  }
+
+  // This will just return the property on the `data` object
+  get(key) {
+    return this.data[key];
+  }
+
+  // ...and this will set it
+  set(key, val) {
+    this.data[key] = val;
+    // Wait, I thought using the node.js' synchronous APIs was bad form?
+    // We're not writing a server so there's not nearly the same IO demand on the process
+    // Also if we used an async API and our app was quit before the asynchronous write had a chance to complete,
+    // we might lose that data. Note that in a real app, we would try/catch this.
+    fs.outputFileSync(this.path, JSON.stringify(this.data, null, 2));
+  }
+
+  trim(key, size) {}
+
+  // ...and this will added.
+  // PostConditions: element will be inserted at the beginning of the array, and removed any other instance of that element in the array.
+  addUnique(key, val, maxSizeBeforeTrim) {
+    let values = this.get(key) || [];
+    if (!Array.isArray(values)) {
+      throw new Error(
+        `Key: ${key} be an array. File: ${this.configName} may be corrupted`
+      );
+    }
+
+    // insert element if array and remove if existing already
+    if (values.indexOf(val) >= 0) {
+      values.splice(values.indexOf(val), 1);
+      values.unshift(val);
+    } else {
+      values.unshift(val);
+    }
+
+    // update the array with the new value and take care in case we need to trim the size of recent projects
+    if (values.length > maxSizeBeforeTrim) {
+      this.set(key, values.slice(0, maxSizeBeforeTrim));
+    } else {
+      this.set(key, values);
+    }
+  }
+}
+
+function parseDataFile(filePath, defaults) {
+  // We'll try/catch it in case the file doesn't exist yet, which will be the case 
+  // on the first application run.
+  // `fs.readFileSync` will return a JSON string which we then 
+  // parse into a Javascript object
+  try {
+    return JSON.parse(fs.readFileSync(filePath));
+  } catch (error) {
+    // if there was some kind of error, return the passed in defaults instead.
+    return defaults;
+  }
+}
+
+// expose the class
+module.exports = Store;

package/src/app/lib/stores/test-config-store.js

@@ -0,0 +1,26 @@
+// properties
+const defaultKeys = {
+    test: {}
+  };
+  
+  const Store = require('./store');
+  
+  class TestConfigStore extends Store {
+  
+    constructor(defaults) {
+      super({ ...defaults, configName: '.kumologica/test-config', defaults: {}});
+    }
+  
+    getTestConfig() {
+      return super.get('test');
+    }
+  
+    setTestConfig(value) {
+      super.set('test', value);
+    }
+  }
+  
+  module.exports = {
+    TestConfigStore
+  };
+  

package/src/app/lib/stores/user-preference-store.js

@@ -0,0 +1,44 @@
+// properties
+const defaultKeys = {
+  mainWindowBounds: 'mainWindowBounds',
+  recentProjects: 'recentProjects',
+  untitledProject: 'untitledProject'
+};
+const MAX_NUM_RECENT_PROJECTS = 10;
+
+const Store = require('./store');
+class UserPreferenceStore extends Store {
+  constructor(defaults) {
+    super({ ...defaults, configName: 'user-preferences' });
+  }
+
+  addRecentProject(projectDir) {
+    // make sure we dont include the untitled project to the list of
+    // recent projects
+    if (projectDir.startsWith(super.getUserDataPath())) {
+      return;
+    }
+
+    super.addUnique(
+      defaultKeys.recentProjects,
+      projectDir,
+      MAX_NUM_RECENT_PROJECTS
+    );
+  }
+  getRecentProjects() {
+    return super.get(defaultKeys.recentProjects);
+  }
+
+  addUntitledProject(projectDir) {
+    super.set(defaultKeys.untitledProject, projectDir);
+  }
+
+  getUntitledProject() {
+    return super.get(defaultKeys.untitledProject);
+  }
+}
+
+module.exports = {
+  UserPreferenceStore,
+  defaultKeys
+};

package/src/app/lib/utils/editor.js

@@ -0,0 +1,98 @@
+  const { shell } = require('electron');
+  const fs = require('fs-extra');
+  const path = require('path');
+  const glob = require('glob');
+  const { promisify } = require('util');
+  const g = promisify(glob);
+
+  function openFolder(path){
+    if (!path) {
+      console.log('Path cannot be empty');
+      return;
+    }
+    shell.openExternal('file://' + path);
+   // shell.openItem(path);
+  }
+  /**
+   * openFileOnEditor - opens a file on the native editor
+   * @param {string} fileName - full path to the file to open.
+   */
+  function openFileOnEditor(fileName) {
+    
+    if (!fileName) {
+      console.log('Filename cannot be empty');
+      return;
+    }
+
+    try{
+      let cmd = '';
+      switch (process.platform) {
+        case 'darwin':
+          cmd = 'open -t';
+          break;
+        case 'win32':
+          cmd = 'notepad';
+          break;
+        case 'win64':
+          cmd = 'notepad';
+          break;
+        default:
+          cmd = 'xdg-open';
+      }
+
+      let exec = require('child_process').exec;
+      exec(`${cmd} "${fileName}"`);
+    } catch(err){
+      throw err;
+    }
+    
+  }
+
+  function isValidFlowFile(filename) {
+    if (filename && path.extname(filename) === '.json'){         
+      try{
+        let flowFile = JSON.parse(fs.readFileSync(filename));
+        
+        if (Array.isArray(flowFile)) {
+          let nodes = flowFile.filter(node => {
+            return(
+              node.hasOwnProperty('id') && 
+              node.hasOwnProperty('type') &&
+              node.hasOwnProperty('name'))
+          })
+          return (nodes.length >= 2);
+        } else {
+          return false;
+        }
+
+      } catch (err) {
+        // console.log(`Error found: ${filename} is not a valid flow file`)
+        return false;
+      }
+    } else {
+      return false;
+    }
+    
+  }
+
+  async function findAllFlowFiles(src) {
+    let onlyJsonFilesPredicate = path.join(src, '*.json');
+    let result = await g(onlyJsonFilesPredicate);
+
+    let onlyFlowfiles = result
+      .filter(f => !f.includes('/node_modules'))
+      .filter(f => !f.includes('/deploy'))
+      .filter(f => !f.includes('/build'))
+      .map(f => f.split('/').join(path.sep))
+      .filter(f => isValidFlowFile(f));
+
+    return onlyFlowfiles;
+  };
+
+  module.exports = {
+    openFileOnEditor,
+    openFolder,
+    isValidFlowFile,
+    findAllFlowFiles
+  } 
+

package/src/app/lib/utils/fix-path.js

@@ -0,0 +1,15 @@
+'use strict';
+const shellPath = require('shell-path');
+
+module.exports = () => {
+	if (process.platform === 'win32' || process.platform === 'win64') {
+		return;
+	}
+
+	process.env.PATH = shellPath.sync() || [
+		'./node_modules/.bin',
+		'/.nodebrew/current/bin',
+		'/usr/local/bin',
+		process.env.PATH
+	].join(':');
+};

package/src/app/main-process/main-window.js

@@ -0,0 +1,209 @@
+const electron = require('electron');
+const path = require('path');
+const fs = require('fs-extra');
+const url = require('url');
+const { defaultKeys } = require('../lib/stores/user-preference-store');
+const { BrowserWindow } = electron;
+const EventEmitter = require('events');
+let { ipcMain } = electron;
+
+// using electron-updater instead of builtin autoUpdater
+// see why: https://www.electron.build/auto-update
+const { autoUpdater } = require('electron-updater');
+
+const preloadJsPath = path.join(__dirname, '..', 'preload.js');
+
+class MainWindow {
+  window = null;
+  shown = false;
+  startupErrorEvent = null;
+
+  /**
+   *
+   * @param {UserPreferenceStore} store
+   */
+  constructor(store, projectDir, flowfilePath) {
+    this.store = store;
+    this.lastUserProjectDir = projectDir;
+    if (flowfilePath){
+      this.lastFlowfile = flowfilePath;
+    }
+   
+    this.emitter = new EventEmitter();
+    const { width, height } = store.get(defaultKeys.mainWindowBounds);
+
+    let windowOptions = {
+      title: 'Kumologica Designer',
+      width: width,
+      height: height,
+      backgroundColor: '#fff',
+      titleBarStyle: 'hiddenInset',
+      icon: "./src/assets/kumologica-app.png",
+      webPreferences: {
+        nodeIntegration: false,
+        preload: preloadJsPath,
+        contextIsolation: false
+      },
+      show: false,
+      icon: path.join(__dirname, '../ui/editor-client/src/kumologica-app.png'),
+    };
+
+    this.window = new BrowserWindow(windowOptions);
+    this.window.maximize();
+
+    this.window.on('focus', () => this.window.webContents.send('focus'));
+    this.window.on('blur', () => this.window.webContents.send('blur'));
+    this.window.on('resize', () => {
+      // The event doesn't pass us the window size, so we call the `getBounds`
+      // method which returns an object with
+      // the height, width, and x and y coordinates.
+      let { width, height } = this.window.getBounds();
+      // Now that we have them, save them using the `set` method.
+      this.store.set(defaultKeys.mainWindowBounds, { width, height });
+    });
+
+    // this is not called when maxize was called before (line 45)
+    this.window.once('ready-to-show', () => {
+      this.show();
+    });
+
+    this.window.on('page-title-updated', (e) => {
+      e.preventDefault();
+    });
+
+    this.window.on('closed', () => {
+      // Dereference the window object, usually you would store windows
+      // in an array if your app supports multi windows, this is the time
+      // when you should delete the corresponding element.
+      this.window = null;
+    });
+
+    this.window.webContents.on('did-finish-load', () => {
+      // this.checkForUpdates();
+      this.updateProjectInfo(this.lastUserProjectDir, this.lastFlowfile || "untitled");
+      this.emitter.emit('did-load', null);
+
+      if (this.startupErrorEvent) {
+        this.window.webContents.send(
+          'ui-runtime-startup-error',
+          this.startupErrorEvent
+        );
+      }
+    });
+
+    autoUpdater.on('update-available', () => {
+      this.window.webContents.send('ui-update-available');
+    });
+
+    ipcMain.on('download-app', () => {
+      autoUpdater.downloadUpdate();
+    });
+
+    autoUpdater.on('update-downloaded', () => {
+      this.window.webContents.send('ui-update-downloaded');
+    });
+
+    ipcMain.on('restart-app', () => {
+      autoUpdater.quitAndInstall();
+    });
+
+    ipcMain.on('menu-check-for-updates', () => {
+      this.checkForUpdates();
+    });
+
+    ipcMain.on('runtime-startup-error', (event) => {
+      this.startupErrorEvent = event; // storing event until window init completes
+      //this.window.webContents.send('ui-runtime-startup-error', event);
+    });
+  }
+
+  load() {
+    this.window.loadURL(
+      url.format({
+        pathname: '127.0.0.1:1880',
+        protocol: 'http:',
+        slashes: true,
+      }),
+      {
+        userAgent: 'Kumologica Designer'
+      }
+    );
+  }
+
+  sendEventToRenderer(event){
+    this.window.webContents.send(event);
+  }
+
+  checkForUpdates() {
+    autoUpdater.autoDownload = false;
+    autoUpdater.checkForUpdates().catch(console.error);
+  }
+
+  // TODO: #javier - show error if flow file is not found
+  updateProjectInfo(newProjectDir, flowFilePath) {
+    this.lastUserProjectDir = newProjectDir;
+    this.lastFlowfile = flowFilePath;
+    try {
+      this.window.webContents.send('setProjectInfo', {
+        payload: {
+          projectDir: this.lastUserProjectDir,
+          projectName: path.basename(this.lastUserProjectDir),
+          projectStatus: 'running',
+          flowFile: this.lastFlowfile.substring(this.lastFlowfile.lastIndexOf(path.sep)+1), // including json
+          fullPathFlowFile: flowFilePath
+        },
+      });
+    } catch (Error) {
+      console.log('error: ' + JSON.stringify(Error));
+      throw Error;
+    }
+  }
+
+  focus() {
+    this.window.focus();
+  }
+
+  show() {
+    if (!this.window) {
+      this.load(this.lastUserProjectDir);
+    }
+    this.window.show();
+    this.shown = true;
+  }
+
+  hide() {
+    if (!this.window) {
+      this.load(this.lastUserProjectDir);
+    }
+    this.window.hide();
+    this.shown = false;
+  }
+
+  isShown() {
+    return this.shown;
+  }
+
+  reload() {
+    if (!this.window) {
+      this.load();
+    }
+    this.window.reload();
+  }
+
+  close() {
+    this.window.close();
+  }
+
+  get window() {
+    return this.window;
+  }
+  /**
+   * Register a function to call when the window is done loading. At that point
+   * the page has loaded and the renderer has signalled that it is ready.
+   */
+  onDidLoad(fn) {
+    return this.emitter.once('did-load', fn);
+  }
+}
+
+module.exports = MainWindow;