@kumologica/sdk 3.0.0

package/src/app/main.js

@@ -0,0 +1,590 @@
+/**
+ * ipcMain.on('ch', (e.msg){}) <---------------------- ipcRenderer.send('reply', msg)
+ * win.webContents.send('message', msg) -------------> ipcRenderer.on('message' (e,msg){})
+ */
+const electron = require('electron');
+const fixPath = require('./lib/utils/fix-path.js');
+const util = require('util');
+const path = require('path');
+const exec = util.promisify(require('child_process').exec);
+const request = require('request');
+const requestAsync = util.promisify(request);
+const has = require('lodash/has');
+
+// using electron-updater instead of builtin autoUpdater
+// see why: https://www.electron.build/auto-update
+//const { autoUpdater } = require('electron-updater');
+
+const fs = require('fs');
+let { app, Menu, ipcMain, shell } = electron;
+
+const { appMenu, dockMenu } = require('./main-process/menu');
+const RuntimeManager = require('./main-process/runtime-manager');
+const { codegen } = require('@kumologica/builder');
+
+const MainWindow = require('./main-process/main-window');
+const ModalNewProject = require('./main-process/modal-newproject');
+const ModalHome = require('./main-process/modal-home');
+const ModalWelcome = require('./main-process/modal-welcome');
+const EventEmitter = require('events');
+const ModalNodeLibrary = require('./main-process/modal-nodelibrary');
+
+const {
+  UserPreferenceStore,
+  defaultKeys,
+} = require('./lib/stores/user-preference-store');
+
+const runtimeManager = new RuntimeManager();
+
+// Reference to the BrowserWindows
+let mainWindow;
+let currentModalWindow;
+
+// Preference store
+let userPrefStore;
+
+fixPath();
+
+class WindowsController {
+  constructor() {
+    // Flag to avoid closing the app when all windows are closed. This is required
+    // as welcome page will close all windows before loading the main window
+    this.keepAppRunningIfAllWindowsClosed = false;
+  }
+  setKeepAppRunningIfAllWindowsClosed(on) {
+    this.keepAppRunningIfAllWindowsClosed = on;
+  }
+  isKeepRunning() {
+    return this.keepAppRunningIfAllWindowsClosed;
+  }
+}
+let winController = new WindowsController();
+
+// Disable security warnings
+process.env['ELECTRON_DISABLE_SECURITY_WARNINGS'] = 'true';
+
+// ***** Events from 'modal-welcome *****
+ipcMain.on('modal-welcome:show-dialog-newproject', async () => {
+  winController.setKeepAppRunningIfAllWindowsClosed(true);
+  currentModalWindow.close();
+  let userDir = codegen.generateInitialCode(
+    userPrefStore.getUserDataPath(),
+    'untitled',
+    null,
+    process.env.npm_package_version
+  );
+
+  await openProjectEditor(userDir, () => {
+    showNewProjectDialog(false);
+  });
+  winController.setKeepAppRunningIfAllWindowsClosed(false);
+});
+
+ipcMain.on('modal-welcome:show-dialog-openproject', async () => {
+  let openDialog = electron.dialog;
+  let options = {
+    title: 'Open project directory',
+    properties: ['openDirectory'],
+  };
+  openDialog
+    .showOpenDialog(currentModalWindow.window, options)
+    .then(async (result) => {
+      if (result.canceled) {
+        // what to do when canceled?
+      } else {
+        let userDir = result.filePaths[0];
+        winController.setKeepAppRunningIfAllWindowsClosed(true);
+        currentModalWindow.close();
+        await openProjectEditor(userDir);
+        winController.setKeepAppRunningIfAllWindowsClosed(false);
+      }
+    });
+});
+
+// **** Events from "modal-home" ****
+
+ipcMain.on('modal-home:show-dialog-newproject', () => {
+  currentModalWindow.close();
+  showNewProjectDialog(true);
+});
+
+ipcMain.on('modal-home:show-dialog-openproject', () => {
+  currentModalWindow.close();
+  showOpenProjectDialog(mainWindow.window);
+});
+
+ipcMain.on('modal-home:open-project-in-editor', async (event, msg) => {
+  currentModalWindow.close();
+  await openProjectEditor(msg.payload.projectLocation);
+});
+
+// menu  events
+
+ipcMain.on('menu-help-documentation', () => {
+  shell.openExternal('https://docs.kumologica.com/docs/guide/Intro.html');
+});
+
+ipcMain.on('menu-help-training-videos', () => {
+  shell.openExternal(
+    'https://www.youtube.com/channel/UCsTDAlhijUFpsfThJu3hF9g'
+  );
+});
+
+ipcMain.on('menu-help-release-notes', () => {
+  shell.openExternal(
+    'https://github.com/KumologicaHQ/kumologica-designer-releases/releases/'
+  );
+});
+
+ipcMain.on('menu-help-join-twitter', () => {
+  shell.openExternal('https://twitter.com/kumologica');
+});
+
+ipcMain.on('menu-help-join-discord', () => {
+  shell.openExternal('https://discord.com/invite/HrTCY8zXxM');
+});
+
+ipcMain.on('kumologica-contact-us', ()=> {
+  shell.openExternal('https://kumologica.com/contact.html');
+})
+
+// **** Events from 'NewProject modal' ****
+
+ipcMain.on('modal-projects:close', () => {
+  if (currentModalWindow.isCancellable()) {
+    currentModalWindow.close();
+  } else {
+    // Exit app by closing all windows
+    currentModalWindow.close();
+    mainWindow.close();
+  }
+});
+
+ipcMain.on('modal-projects:create-project', async (event, payload) => {
+  const { projectName, projectBaseDir, flow } = payload;
+
+  app.addRecentDocument(projectBaseDir);
+
+  currentModalWindow.close();
+  const projectDir = codegen.generateInitialCode(
+    projectBaseDir, 
+    projectName, 
+    flow,
+    process.env.npm_package_version
+ );
+  await openProjectEditor(projectDir);
+});
+
+// Events from menu
+
+ipcMain.on('core:show-import-dialog', ()=> {
+  mainWindow.sendEventToRenderer("core:show-import-dialog");
+});
+
+ipcMain.on('core:show-export-dialog', ()=> {
+  mainWindow.sendEventToRenderer("core:show-export-dialog");
+});
+
+ipcMain.on('core:search', ()=> {
+  mainWindow.sendEventToRenderer("core:search");
+});
+
+ipcMain.on('core:search', ()=> {
+  mainWindow.sendEventToRenderer("core:search");
+});
+
+ipcMain.on('core:toggle-terminal', ()=> {
+  mainWindow.sendEventToRenderer("core:toggle-terminal");
+});
+ipcMain.on('core:toggle-palette', ()=> {
+  mainWindow.sendEventToRenderer("core:toggle-palette");
+});
+ipcMain.on('core:view-main-workspace', ()=> {
+  mainWindow.sendEventToRenderer("core:view-main-flow");
+});
+ipcMain.on('core:view-test-workspace', ()=> {
+  mainWindow.sendEventToRenderer("core:view-test-flow");
+});
+ipcMain.on('core:view-settings', ()=> {
+  mainWindow.sendEventToRenderer("core:toggle-settings");
+});
+ipcMain.on('show-newProject-modal', () => {
+  showNewProjectDialog(true);
+});
+ipcMain.on('show-openProject-dialog', () => {
+  showOpenProjectDialog();
+});
+ipcMain.on('app_version', (event) => {
+  event.sender.send('app_version', { version: app.getVersion() });
+});
+ipcMain.on('main-header:show-modal-home', () => {
+  currentModalWindow = new ModalHome(findRecentProjects());
+  currentModalWindow.load();
+});
+
+// ***** Events from modal-node-library  *****
+
+// - Modal window launch event
+
+ipcMain.on('show-node-library-modal', () => {
+  currentModalWindow = new ModalNodeLibrary();
+  currentModalWindow.load();
+});
+
+// Ask for the project directory
+ipcMain.on('modal-node-library:fetch-installed-nodes', (event, payload) => {
+  let results = [];
+  let projectDir = runtimeManager.getCurrentUserDir();
+  try {
+    const packageJsonPath = path.join(projectDir, 'package.json');
+    let data = fs.readFileSync(packageJsonPath, 'utf-8');
+    const pkg = JSON.parse(data);
+    const dependencies = pkg.dependencies;
+    results = Object.keys(dependencies).filter((dep) =>
+      dep.includes('kumologica-contrib')
+    );
+  } catch (err) {
+    console.log(err);
+    throw new Error(
+      `package.json file not found in the project directory: ${projectDir}`
+    );
+  }
+  event.sender.send('modal-node-library:fetch-installed-nodes-response', {
+    installedNodes: results,
+  });
+});
+
+// - Install package command event
+ipcMain.on('modal-node-library:install-package', async (event, payload) => {
+  let { source } = payload;
+
+  // Send signal to modal window that we are going to start installing it
+  event.sender.send('modal-node-library:install-package-initiated', {
+    source: source,
+  });
+
+  // Dev Dependencies to be installed
+  if (source.hasOwnProperty('devPackages')) {
+    let devDependencies = source['devPackages'].join(' ');
+    const npmCmd = `npm install --save-dev ${devDependencies}`;
+    const currentProjectDir = runtimeManager.getCurrentUserDir();
+    await exec(npmCmd, { cwd: currentProjectDir });
+  }
+
+  // Dependency to be installed
+  let dependency = source.package;
+
+  // Execute the command: npm install <package>
+  const npmCmd = `npm install --save ${dependency}`;
+  const currentProjectDir = runtimeManager.getCurrentUserDir();
+  await exec(npmCmd, { cwd: currentProjectDir });
+
+  // Send signal to modal window that we have finished with the installation and a restart is required
+  event.sender.send('modal-node-library:install-package-finished', {
+    source: source,
+  });
+});
+
+// - Uninstall package command event
+ipcMain.on('modal-node-library:uninstall-package', async (event, payload) => {
+  let { source } = payload;
+
+  // Execute the command: npm install <package>
+  const npmCmd = `npm uninstall ${source.package}`;
+  const currentProjectDir = runtimeManager.getCurrentUserDir();
+  await exec(npmCmd, { cwd: currentProjectDir });
+
+  // Send signal to modal window that we have finished with the installation and a restart is required
+  event.sender.send('modal-node-library:uninstall-package-finished', {
+    source: source,
+  });
+});
+ipcMain.on('restart-requested', async (event, msg) => {
+  // reload the nodes available in the palette
+  try {
+    await requestAsync({
+      uri: `http://127.0.0.1:1880/nodes-reload`,
+      method: 'POST',
+      json: true,
+    });
+  } catch (err) {
+    console.log(`Error in the main when reloading nodes`, err);
+  }
+  // refresh button
+  mainWindow.reload();
+});
+
+ipcMain.on('modal-node-library:restart-requested', async (event, msg) => {
+  currentModalWindow.close();
+  // reload the nodes available in the palette
+  try {
+    await requestAsync({
+      uri: `http://127.0.0.1:1880/nodes-reload`,
+      method: 'POST',
+      json: true,
+    });
+  } catch (err) {
+    console.log(`Error in the main when reloading nodes`, err);
+  }
+  // refresh button
+  mainWindow.reload();
+});
+
+function showNewProjectDialog(cancellable) {
+  currentModalWindow = new ModalNewProject(mainWindow.window, cancellable);
+  currentModalWindow.load();
+}
+
+function showOpenProjectDialog(parent) {
+  let openDialog = electron.dialog;
+  let options = {
+    title: 'Open project directory',
+    properties: ['openDirectory'],
+  };
+
+  openDialog.showOpenDialog(parent, options).then(async (result) => {
+    if (result.canceled) {
+      // what to do when canceled?
+    } else {
+      let userDir = result.filePaths[0];
+      await openProjectEditor(userDir);
+    }
+  });
+}
+
+function runtimeEventListener(event) {
+  // console.log('runtimeEventListener hit with event:', event);
+  // runtime events @Terminal
+  if (event && event.id && event.id == 'terminal-output' 
+    && mainWindow && mainWindow.window && mainWindow.window.webContents) {
+    mainWindow.window.webContents.send('terminal-output', event);
+  }
+  // runtime events @tests
+  if (event && event.id && event.id.startsWith('test:')
+    && mainWindow && mainWindow.window && mainWindow.window.webContents) {
+    mainWindow.window.webContents.send(event.id, event);
+  }
+
+  if (has(event, 'id') && event.id.startsWith('debugger:')) {
+    mainWindow.window.webContents.send(event.id, event);
+  }
+}
+
+async function openProjectEditor(projectDir, onDidLoad) {
+  try {
+    let startupErrorEvent;
+    startupEmitter = new EventEmitter();
+
+    startupEmitter.on('runtime-startup-error', (event) => {
+      startupErrorEvent = event;
+    });
+
+    let flowFilepath = await runtimeManager.start(projectDir, startupEmitter);
+
+    // Make sure you remove all listeners before you attach new listeners,
+    // otherwise, we will have duplicated listeners on runtime-events
+    // causing the events to trigger multiple times.
+    runtimeManager.appServer.events.removeAllListeners(
+      'runtime-event',
+      runtimeEventListener
+    );
+
+    runtimeManager.appServer.events.on('runtime-event', runtimeEventListener);
+
+    if (mainWindow) {
+      // Updating the project information
+      mainWindow.updateProjectInfo(projectDir, flowFilepath);
+      mainWindow.reload();
+    } else {
+      mainWindow = new MainWindow(userPrefStore, projectDir, flowFilepath);
+      if (onDidLoad) {
+        mainWindow.onDidLoad(onDidLoad);
+      }
+      mainWindow.load();
+    }
+
+    // Add new project to the recent of project list in the preference store
+    userPrefStore.addRecentProject(projectDir);
+    app.addRecentDocument(projectDir);
+
+    if (startupErrorEvent) {
+      ipcMain.emit('runtime-startup-error', startupErrorEvent);
+    }
+  } catch (err) {
+    throw err;
+    // Error found while starting the runtime ...
+    // find out the parent window
+    // let parentWindow = null;
+    // if (!mainWindow && !currentModalWindow) {
+    //   parentWindow = null;
+    // } else {
+    //   parentWindow = mainWindow ? mainWindow.window : currentModalWindow.window;
+    // }
+
+    // let openDialog = electron.dialog;
+    // let options = {
+    //   type: 'error',
+    //   buttons: ['OK'],
+    //   message: `Kumologica Designer is unable to open project`,
+    //   detail: `${err}`,
+    // };
+    // openDialog.showMessageBoxSync(parentWindow, options, async (response) => {
+    //   // no need to do anything, the runtime has already been recovered with a safe userDir
+    //   // empty project if welcome, or previous valid project if main.
+    // });
+  }
+}
+
+async function openWelcomePage() {
+  if (mainWindow) {
+    await runtimeManager.stop();
+    winController.setKeepAppRunningIfAllWindowsClosed(true);
+    mainWindow.close();
+  }
+  // There is no project recently opened - we will create one just to kick the runtime
+  // This project will be created in the dataPath of the store:
+  // ~/Library/Application Support/Kumologica
+  let userDir = codegen.generateInitialCode(
+    userPrefStore.getUserDataPath(),
+    'untitled',
+    null,
+    process.env.npm_package_version
+ 
+  );
+
+  // // lets give a kick to the runtime
+  await runtimeManager.start(userDir);
+
+  // Open the modal home in headless mode, i.e. without editor on
+  // So a couple of conditions apply here, user cannot cancel the
+  // newProject dialog, and the modal will remain opened, if user
+  // cancel the openProject dialog.
+  currentModalWindow = new ModalWelcome();
+  currentModalWindow.load();
+
+  // Reset the close app behaviour
+  winController.setKeepAppRunningIfAllWindowsClosed(false);
+}
+/**
+ * Look in the user preference store for the latest project opened by user
+ * @returns Array of project directory (absolute path) or empty array otherwise
+ */
+function findRecentProjects() {
+  return userPrefStore.getRecentProjects();
+}
+
+/**
+ * Look in the user preference store for the latest project opened by user
+ * @returns latest project directory (absolute path) or `undefined` otherwise
+ */
+function findLatestProject() {
+  let recentProjects = findRecentProjects();
+  if (
+    recentProjects &&
+    recentProjects.length >= 1 &&
+    recentProjects[0] &&
+    fs.existsSync(recentProjects[0])
+  ) {
+    return recentProjects[0];
+  } else {
+    return undefined;
+  }
+}
+
+// This method will be called when Electron has finished
+// initialization and is ready to create browser windows.
+// Some APIs can only be used after this event occurs.
+app.on('ready', async () => {
+  Menu.setApplicationMenu(appMenu);
+  if (app.dock) {
+    app.dock.setMenu(dockMenu);
+  }
+
+  // Lets instantiate our user preference store
+  const { width, height } = electron.screen.getPrimaryDisplay().workAreaSize;
+
+  // Initialize with first time defaults
+  let defaults = {};
+  defaults[defaultKeys.mainWindowBounds] = { width, height };
+  userPrefStore = new UserPreferenceStore({ defaults: defaults });
+
+  // Find out the latest project that user used last time
+  let projectDir = process.argv[2]? process.argv[2]: findLatestProject(); // argv=[electron_path, main.js-path, kumologica-project-path]
+  
+  try{
+    if (projectDir) {
+      await openProjectEditor(projectDir);
+    } else {
+      await openWelcomePage();
+    }
+  }catch(e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+  // autoUpdater.checkForUpdates().catch(console.error);
+  //autoUpdater.checkForUpdatesAndNotify(); //.catch(console.error);
+});
+
+// event triggered from open recent api
+app.on('open-file', (event, path) => {
+  event.preventDefault();
+  openProjectEditor(path, true);
+});
+
+// Called before quitting...gives us an opportunity to shutdown the child process
+app.on('before-quit', async () => {
+  console.log('[main] gracefully shutting down...');
+
+  // Kill the web process
+  await runtimeManager.stop();
+  // if (mainWindow) {
+  //   mainWindow.close();
+  // }
+});
+
+// Quit when all windows are closed.
+app.on('window-all-closed', function () {
+  if (!winController.isKeepRunning()) {
+    //recreateWindowRequired = true;
+    // mainWindow.window.destroy();
+    // On OS X it is common for applications and their menu bar
+    // to stay active until the user quits explicitly with Cmd + Q
+    //if (process.platform !== 'darwin') {
+
+    // Doing exit instead of quit, otherwise in Mac will understand
+    // that quit as a `exit unxpectedly` error.
+    app.quit();
+    app.exit(0);
+  }
+});
+
+app.on('activate', function () {
+  // On OS X it's common to re-create a window in the app when the
+  // dock icon is clicked and there are no other windows open.
+  if (mainWindow === null) {
+    createWindow();
+  }
+});
+
+//if (process.platform === "win32") {
+//	var rl = require("linebyline").createInterface({
+//		input: process.stdin,
+//		output: process.stdout
+//	});
+//
+//	rl.on("SIGINT", function () {
+//		process.emit("SIGINT");
+//	});
+//}
+/*
+autoUpdater.on('update-available', () => {
+  this.mainWindow.webContents.send('ui-update-available');
+  autoUpdater.downloadUpdate();
+});
+*/
+
+process.on('SIGINT', function () {
+  //graceful shutdown
+  console.log('SIGNINT SENT');
+  process.exit();
+});