Merge pull request #72 from appworks-lab/release-next

Release 0.4.0

Author: luhc228

CHANGELOG.md

@@ -1,17 +1,24 @@
 # CHANGELOG
 
+## 0.4.0
+
+- Feat: add base packages info cache
+- Feat: support view app or tool details
+- Feat: enhance app updates and show the changelog
+- Feat: support build an asar package
+
 ## 0.3.0
 
 - Feat: support install tnpm or cnpm
 - Feat: support install mac app
 - Feat: support install chrome extension
 - Feat: smaller window size
-- chore: update readme
+- Chore: update readme
 
 ## 0.2.1
 
 - Fix: fail to get internal npm package info
-- Feat: use default shell to excute sh file
+- Feat: use default shell to execute sh file
 - Feat: add global dependencies prefix path
 - Feat: add recommend icon to registry
 - Feat: update log to sls
@@ -34,4 +41,4 @@
 ## 0.1.0
 
 - Feat: fast install packages, including VS Code/Git/Node.js/AppWorks/Chrome
-- Feat: node version manager
+- Feat: node version manager

main/utils/autoUpdater.ts renamed to main/autoUpdater/index.ts

@@ -1,6 +1,10 @@
 import { NsisUpdater, MacUpdater, AppImageUpdater } from 'electron-updater';
-import * as isDev from 'electron-is-dev';
-import log from './log';
+import { app } from 'electron';
+import fetch from 'node-fetch';
+import log from '../utils/log';
+import { createUpdaterWindow, sendToUpdaterWindow } from '../window';
+
+const { version: currentVersion } = require('../../package.json');
 
 let AutoUpdater;
 if (process.platform === 'win32') {
@@ -19,28 +23,57 @@ autoUpdater.logger.transports.file.level = 'info';
 autoUpdater.on('checking-for-update', () => {
   log.info('checking-for-update');
 });
+
 autoUpdater.on('update-available', (info) => {
   log.info('update-available', info);
 });
+
 autoUpdater.on('update-not-available', (info) => {
   log.info('update-not-available', info);
 });
+
 autoUpdater.on('error', (error) => {
   log.error('error', error);
 });
+
 autoUpdater.on('download-progress', (meta) => {
   log.info('download-progress', meta);
 });
+
 autoUpdater.on('update-downloaded', (info) => {
   log.info('update-downloaded', info);
+  const { version: latestVersion } = info;
+  app.whenReady()
+    .then(() => {
+      return createUpdaterWindow();
+    })
+    .then(() => {
+      return fetchChangelog(latestVersion);
+    })
+    .then((changelog) => {
+      sendToUpdaterWindow('update-info', {
+        currentVersion,
+        latestVersion,
+        changelog,
+      });
+    })
+    .catch((e) => {
+      log.error(e);
+    });
 });
 
 export function checkForUpdates() {
-  if (isDev) {
+  if (process.env.NODE_ENV === 'development') {
     return;
   }
-  autoUpdater.checkForUpdates();
+
+  return autoUpdater.checkForUpdates();
 }
 
-export default autoUpdater;
+async function fetchChangelog(version: string) {
+  const res = await fetch(`https://iceworks.oss-cn-hangzhou.aliyuncs.com/toolkit/changelog/${version}.json`);
+  const content = await res.json();
+  return content;
+}
 
+export default autoUpdater;

main/data/data.json

@@ -1,12 +1,13 @@
 import { app, BrowserWindow } from 'electron';
 import modifyProcessEnv from './utils/modifyProcessEnv';
-import { createWindow } from './window';
+import { createMainWindow } from './window';
 import handleIPC from './ipc';
-import { checkForUpdates } from './utils/autoUpdater';
+import { checkForUpdates } from './autoUpdater';
 import getPackagesData from './utils/getPackagesData';
 import { autoDownloadPackages } from './autoDownloader';
 import store, { packagesDataKey } from './store';
 import { recordDAU } from './recorder';
+import setMenu from './menu';
 
 process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = 'true';
 
@@ -18,21 +19,26 @@ app.whenReady()
   .finally(() => {
     modifyProcessEnv();
 
-    createWindow();
+    createMainWindow();
 
     handleIPC();
 
-    checkForUpdates();
-
-    autoDownloadPackages();
-
-    recordDAU();
+    setMenu();
 
     app.on('activate', () => {
-      if (BrowserWindow.getAllWindows().length === 0) createWindow();
+      if (BrowserWindow.getAllWindows().length === 0) createMainWindow();
     });
   });
 
+
+app.on('will-finish-launching', () => {
+  checkForUpdates();
+
+  autoDownloadPackages();
+
+  recordDAU();
+});
+
 // Quit when all windows are closed.
 app.on('window-all-closed', () => {
   if (process.platform !== 'darwin') app.quit();

main/index.ts

@@ -1,11 +1,18 @@
-import { ipcMain } from 'electron';
+import { ipcMain, IpcMainInvokeEvent } from 'electron';
 import { BasePackageInfo, Platform } from '../types';
 import { getPackageInfo } from '../packageInfo';
 import checkIsAliInternal from '../utils/checkIsAliInternal';
 import store, { packagesDataKey } from '../store';
+import nodeCache from '../utils/nodeCache';
+
+const basePackagesInfoKey = 'basePackagesInfo';
 
 export default () => {
-  ipcMain.handle('get-base-packages-info', async () => {
+  ipcMain.handle('get-base-packages-info', async (e: IpcMainInvokeEvent, force = false) => {
+    const cache = nodeCache.get(basePackagesInfoKey);
+    if (!force && cache) {
+      return cache;
+    }
     const data = store.get(packagesDataKey);
     const { bases = [] }: { bases: BasePackageInfo[] } = data;
     const isAliInternal = await checkIsAliInternal();
@@ -22,6 +29,9 @@ export default () => {
     const packagesData = await Promise.all(basePackages.map((basePackageInfo: BasePackageInfo) => {
       return getPackageInfo(basePackageInfo);
     }));
+
+    nodeCache.set(basePackagesInfoKey, packagesData);
+
     return packagesData;
   });
 };

main/ipc/getBasePackagesInfo.ts

@@ -9,7 +9,7 @@ import checkIsAliInternal from '../utils/checkIsAliInternal';
 import log from '../utils/log';
 import killChannelChildProcess from '../utils/killChannelChildProcess';
 import { record } from '../recorder';
-import { send as sendMainWindow } from '../window';
+import { sendToMainWindow } from '../window';
 
 const childProcessMap = new Map();
 
@@ -54,29 +54,32 @@ export default () => {
       log.info(`Channel ${childProcessName} has an existed child process.`);
       return;
     }
-    // fork a child process to install package
     childProcess = child_process.fork(path.join(__dirname, '..', 'packageManager/index'));
     childProcessMap.set(childProcessName, childProcess);
     const packagesData = store.get(packagesDataKey);
     childProcess.send({ packagesList: [packageInfo], packagesData, uninstallChannel, processChannel, type: 'uninstall' });
 
     childProcess.on('message', ({ channel, data }: any) => {
       if (channel === processChannel) {
-        if (data.status === 'done') {
-          record({
-            module: 'app',
-            action: 'uninstall',
-            data: {
-              name: packageInfo.title,
-            },
-          });
-        }
-        if (data.status === 'done' || data.status === 'error') {
-          killChannelChildProcess(childProcessMap, childProcessName);
+        switch (data.status) {
+          case 'done':
+            record({
+              module: 'app',
+              action: 'uninstall',
+              data: {
+                name: packageInfo.title,
+              },
+            });
+          // eslint-disable-next-line no-fallthrough
+          case 'error':
+            killChannelChildProcess(childProcessMap, childProcessName);
+            break;
+          default:
+            break;
         }
       }
 
-      sendMainWindow(channel, data);
+      sendToMainWindow(channel, data);
     });
   });
 
@@ -90,29 +93,36 @@ export default () => {
       log.info(`Channel ${childProcessName} has an existed child process.`);
       return;
     }
-    // fork a child process to install package
+    /**
+     * we need to cancel the install process
+     * so we create a childProcess and we can kill it later
+     */
     childProcess = child_process.fork(path.join(__dirname, '..', 'packageManager/index'));
     childProcessMap.set(childProcessName, childProcess);
     const packagesData = store.get(packagesDataKey);
     childProcess.send({ packagesList: [packageInfo], packagesData, installChannel, processChannel });
 
     childProcess.on('message', ({ channel, data }: any) => {
       if (channel === processChannel) {
-        if (data.status === 'done') {
-          record({
-            module: 'app',
-            action: 'install',
-            data: {
-              name: packageInfo.title,
-            },
-          });
-        }
-        if (data.status === 'done' || data.status === 'error') {
-          killChannelChildProcess(childProcessMap, childProcessName);
+        switch (data.status) {
+          case 'done':
+            record({
+              module: 'app',
+              action: 'install',
+              data: {
+                name: packageInfo.title,
+              },
+            });
+          // eslint-disable-next-line no-fallthrough
+          case 'error':
+            killChannelChildProcess(childProcessMap, childProcessName);
+            break;
+          default:
+            break;
         }
       }
 
-      sendMainWindow(channel, data);
+      sendToMainWindow(channel, data);
     });
   });
 };

main/ipc/handleApp.ts

@@ -9,7 +9,7 @@ import { getPackageInfo } from '../packageInfo';
 import log from '../utils/log';
 import { record } from '../recorder';
 import killChannelChildProcess from '../utils/killChannelChildProcess';
-import { send as sendMainWindow } from '../window';
+import { sendToMainWindow } from '../window';
 import ping = require('ping');
 
 const childProcessMap = new Map();
@@ -82,25 +82,29 @@ export default () => {
 
     childProcess.on('message', ({ channel, data }: any) => {
       if (channel === processChannel) {
-        if (data.status === 'done') {
-          record({
-            module: 'browserExtension',
-            action: 'install',
-            data: {
-              name: packageInfo.title,
-            },
-          });
-        }
-        if (data.status === 'done' || data.status === 'error') {
-          killChannelChildProcess(childProcessMap, childProcessName);
+        switch (data.status) {
+          case 'done':
+            record({
+              module: 'browserExtension',
+              action: 'install',
+              data: {
+                name: packageInfo.title,
+              },
+            });
+          // eslint-disable-next-line no-fallthrough
+          case 'error':
+            killChannelChildProcess(childProcessMap, childProcessName);
+            break;
+          default:
+            break;
         }
       }
 
-      sendMainWindow(channel, data);
+      sendToMainWindow(channel, data);
     });
   });
 
-  ipcMain.handle('check-webstore-host-alive', async (e: IpcMainInvokeEvent, browserType: string) => {
+  ipcMain.handle('check-webstore-host-is-accessible', async (e: IpcMainInvokeEvent, browserType: string) => {
     const browserHosts = {
       Chrome: 'chrome.google.com',
     };

main/ipc/handleBrowserExtension.ts

@@ -1,7 +1,7 @@
 import * as child_process from 'child_process';
 import * as path from 'path';
 import { ipcMain, IpcMainInvokeEvent } from 'electron';
-import { send as sendMainWindow } from '../window';
+import { sendToMainWindow } from '../window';
 import {
   getGlobalDependencies,
   uninstallGlobalDependency,
@@ -47,6 +47,10 @@ export default () => {
   });
 
   ipcMain.handle('create-custom-global-dependencies-dir', async (e: IpcMainInvokeEvent, channel: string, currentGlobalDepsPath: string) => {
+    /**
+     * we need to cancel the process
+     * so we create a childProcess and we can kill it later
+     */
     const childProcess = child_process.fork(path.join(__dirname, '..', 'npm/dependency/createCustomGlobalDepsDir'));
     childProcessMap.set(channel, childProcess);
 
@@ -55,13 +59,20 @@ export default () => {
     childProcessMap.set(channel, childProcess);
 
     childProcess.on('message', ({ data }: any) => {
-      if (data.status === 'done') {
-        record({
-          module: 'node',
-          action: 'createCustomGlobalDependenciesDir',
-        });
+      switch (data.status) {
+        case 'done':
+          record({
+            module: 'node',
+            action: 'createCustomGlobalDependenciesDir',
+          });
+        // eslint-disable-next-line no-fallthrough
+        case 'error':
+          killChannelChildProcess(childProcessMap, channel);
+          break;
+        default:
+          break;
       }
-      sendMainWindow(channel, data);
+      sendToMainWindow(channel, data);
     });
   });