@lowdefy/server-dev 4.0.0-alpha.6 → 4.0.0-alpha.7

package/src/manager/processes/shutdownServer.mjs

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+function shutdownServer(context) {
+  return () => {
+    if (context.nextServer) {
+      // console.log(
+      //   `Existing server ${context.nextServer.pid}, killed: ${context.nextServer.killed}`
+      // );
+      if (!context.nextServer.killed) {
+        console.log('Shutting down server...');
+        context.nextServer.kill();
+        // console.log(
+        //   `Killed server ${context.nextServer.pid}, killed: ${context.nextServer.killed}`
+        // );
+      }
+      context.nextServer = null;
+    }
+  };
+}
+
+export default shutdownServer;

package/src/manager/processes/startNextServer.mjs

@@ -0,0 +1,45 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import spawnProcess from '../utils/spawnProcess.mjs';
+
+function startServerProcess(context) {
+  context.shutdownServer();
+
+  const nextServer = spawnProcess({
+    logger: console,
+    command: 'node',
+    args: [context.bin.next, 'start'],
+    silent: false,
+    processOptions: {
+      env: {
+        ...process.env,
+        ...context.serverEnv,
+        PORT: context.options.port,
+      },
+    },
+  });
+  // console.log(`Started server ${nextServer.pid}.`);
+  // nextServer.on('exit', (code, signal) => {
+  //   console.log(`nextServer exit ${nextServer.pid}, signal: ${signal}, code: ${code}`);
+  // });
+  nextServer.on('error', (error) => {
+    console.log(error);
+  });
+  context.nextServer = nextServer;
+}
+
+export default startServerProcess;

package/src/manager/processes/startServer.mjs

@@ -15,14 +15,14 @@
 */
 /* eslint-disable no-console */
 
-import startServerProcess from './startServerProcess.mjs';
+import startNextServer from './startNextServer.mjs';
 
 async function startServer(context) {
   return new Promise((resolve, reject) => {
-    context.serverProcessPromise = { resolve, reject };
     try {
-      startServerProcess(context);
+      startNextServer(context);
     } catch (error) {
+      console.log(error);
       reject(error);
     }
   });

package/src/manager/processes/startWatchers.mjs

@@ -0,0 +1,31 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import envWatcher from '../watchers/envWatcher.mjs';
+import lowdefyBuildWatcher from '../watchers/lowdefyBuildWatcher.mjs';
+import nextBuildWatcher from '../watchers/nextBuildWatcher.mjs';
+
+function startWatchers(context) {
+  return async () => {
+    await Promise.all([
+      envWatcher(context),
+      lowdefyBuildWatcher(context),
+      nextBuildWatcher(context),
+    ]);
+  };
+}
+
+export default startWatchers;

package/src/manager/run.mjs

@@ -18,21 +18,72 @@
 import { wait } from '@lowdefy/helpers';
 import opener from 'opener';
 import getContext from './getContext.mjs';
-import initialBuild from './initialBuild.mjs';
 import startServer from './processes/startServer.mjs';
-import startWatchers from './watchers/startWatchers.mjs';
+
+/*
+The run script does the following:
+  - Run the initial Lowdefy build, install plugins, and next build and read .env
+  - Start file watchers to reload config and restart server if necessary
+  - Start the server
+  - Open a browser window.
+
+  Three watchers are started:
+
+  ## Lowdefy build watcher
+  Watches:
+    - <config-dir>,
+    - <watch-dirs>
+    - !<ignore-dirs>
+  The Lowdefy build watcher watches the Lowdefy config files for changes
+  and runs Lowdefy build when they change, and triggers a soft reload.
+
+  If lowdefy version in lowdefy.yaml
+  is changed, the server warns and exits.
+
+  ## .env watcher
+
+  If the .env file is changed, the new file is parsed, and the server restarted with the new env
+  and the server hard reloads.
+
+  ## Next build watcher
+
+  The Next build watcher watches for any files where the app should be rebuilt and restarted.
+  It watches:
+  - <build-dir>/plugins/**
+  - <build-dir>/config.json
+  - <server-dir>/package.json
+
+  If app theme or config changes:
+    - <build-dir>/config.json changes, rebuild and restart server.
+
+  If new plugin type in an existing plugin package is used:
+    - <build-dir>/plugins/** changes,  rebuild next and restart server.
+
+  If new plugin type in a new plugin package is used:
+    - <server-dir>/package.json changes,  run npm install, rebuild next and restart server.
+
+  # Reload mechanism
+
+  The web client creates a Server Sent Events connection with the server on the /api/reload route.
+  The server watches the <build-dir>/reload file, which is written every time the server should reload,
+  and sends an event to the client to reload the config. The client then uses a SWR cache mutation to
+  fetch the new config.
+
+  If the server is restarted, the event stream is closed because the original server was shut down. The client starts
+  pinging the /api/ping route, until it detects a new server has started, and then reloads the window.
+ */
 
 async function run() {
   const context = await getContext();
-  await initialBuild(context);
-  await startWatchers(context);
+  await context.initialBuild();
+  await context.startWatchers();
   try {
     const serverPromise = startServer(context);
     await wait(800);
-    // TODO: set correct port
-    opener(`http://localhost:3000`);
+    opener(`http://localhost:${context.options.port}`);
     await serverPromise;
   } catch (error) {
+    console.log(error);
     context.shutdownServer();
     throw error;
   }

package/src/manager/{BatchChanges.mjs → utils/BatchChanges.mjs}

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */
+/* eslint-disable no-console */
 
 class BatchChanges {
   constructor({ fn, minDelay }) {

package/src/manager/utils/getLowdefyVersion.mjs

@@ -0,0 +1,51 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import path from 'path';
+import { type } from '@lowdefy/helpers';
+import { readFile } from '@lowdefy/node-utils';
+import YAML from 'yaml';
+
+async function getLowdefyVersion(context) {
+  let lowdefyYaml = await readFile(path.join(context.directories.config, 'lowdefy.yaml'));
+  if (!lowdefyYaml) {
+    lowdefyYaml = await readFile(path.join(context.directories.config, 'lowdefy.yml'));
+  }
+  if (!lowdefyYaml) {
+    throw new Error(`Could not find "lowdefy.yaml" file.`);
+  }
+  let lowdefy;
+  try {
+    lowdefy = YAML.parse(lowdefyYaml);
+  } catch (error) {
+    throw new Error(`Could not parse "lowdefy.yaml" file. Received error ${error.message}.`);
+  }
+  if (!lowdefy.lowdefy) {
+    throw new Error(
+      `No version specified in "lowdefy.yaml" file. Specify a version in the "lowdefy" field.`
+    );
+  }
+  if (!type.isString(lowdefy.lowdefy)) {
+    throw new Error(
+      `Version number specified in "lowdefy.yaml" file should be a string. Received ${JSON.stringify(
+        lowdefy.lowdefy
+      )}.`
+    );
+  }
+  return lowdefy.lowdefy;
+}
+
+export default getLowdefyVersion;

package/src/manager/{watchers → utils}/setupWatcher.mjs

@@ -15,14 +15,20 @@
 */
 
 import chokidar from 'chokidar';
-import BatchChanges from '../BatchChanges.mjs';
+import BatchChanges from './BatchChanges.mjs';
 
-function setupWatcher({ callback, watchDotfiles = false, ignorePaths = [], watchPaths }) {
+function setupWatcher({
+  callback,
+  watchDotfiles = false,
+  ignorePaths = [],
+  watchPaths,
+  minDelay = 500,
+}) {
   return new Promise((resolve) => {
     // const { watch = [], watchIgnore = [] } = context.options;
     // const resolvedWatchPaths = watch.map((pathName) => path.resolve(pathName));
 
-    const batchChanges = new BatchChanges({ fn: callback });
+    const batchChanges = new BatchChanges({ fn: callback, minDelay });
     const defaultIgnorePaths = watchDotfiles
       ? []
       : [
@@ -33,9 +39,9 @@ function setupWatcher({ callback, watchDotfiles = false, ignorePaths = [], watch
       persistent: true,
       ignoreInitial: true,
     });
-    configWatcher.on('add', (...args) => batchChanges.newChange(args));
-    configWatcher.on('change', (...args) => batchChanges.newChange(args));
-    configWatcher.on('unlink', (...args) => batchChanges.newChange(args));
+    configWatcher.on('add', (...args) => batchChanges.newChange(...args));
+    configWatcher.on('change', (...args) => batchChanges.newChange(...args));
+    configWatcher.on('unlink', (...args) => batchChanges.newChange(...args));
     configWatcher.on('ready', () => resolve());
   });
 }

package/src/manager/watchers/envWatcher.mjs

@@ -13,13 +13,15 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */
+/* eslint-disable no-console */
 
 import path from 'path';
-import setupWatcher from './setupWatcher.mjs';
+import setupWatcher from '../utils/setupWatcher.mjs';
 
-async function envWatcher(context) {
+function envWatcher(context) {
   const callback = async () => {
-    console.log('.env file changed, restarting server...');
+    console.warn('.env file changed.');
+    await context.readDotEnv();
     context.restartServer();
   };
   return setupWatcher({

package/src/manager/watchers/lowdefyBuildWatcher.mjs

@@ -0,0 +1,45 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+/* eslint-disable no-console */
+
+import getLowdefyVersion from '../utils/getLowdefyVersion.mjs';
+import setupWatcher from '../utils/setupWatcher.mjs';
+
+function lowdefyBuildWatcher(context) {
+  const callback = async (filePaths) => {
+    const lowdefyYamlModified = filePaths
+      .flat()
+      .some((filePath) => filePath.includes('lowdefy.yaml') || filePath.includes('lowdefy.yml'));
+    if (lowdefyYamlModified) {
+      const lowdefyVersion = await getLowdefyVersion(context);
+      if (lowdefyVersion !== context.version && lowdefyVersion !== 'local') {
+        context.shutdownServer();
+        console.warn('Lowdefy version changed. You should restart your development server.');
+        process.exit();
+      }
+    }
+
+    await context.lowdefyBuild();
+    context.reloadClients();
+  };
+  return setupWatcher({
+    callback,
+    ignorePaths: context.options.watchIgnore,
+    watchPaths: [context.directories.config, ...context.options.watch],
+  });
+}
+
+export default lowdefyBuildWatcher;

package/src/manager/watchers/nextBuildWatcher.mjs

@@ -0,0 +1,93 @@
+/*
+  Copyright 2020-2021 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+/* eslint-disable no-console */
+
+import crypto from 'crypto';
+import path from 'path';
+import { readFile } from '@lowdefy/node-utils';
+import setupWatcher from '../utils/setupWatcher.mjs';
+
+const hashes = {};
+
+const watchedFiles = [
+  'build/config.json',
+  'build/plugins/blocks.js',
+  'build/plugins/connections.js',
+  'build/plugins/icons.js',
+  'build/plugins/operatorsClient.js',
+  'build/plugins/operatorsServer.js',
+  'build/plugins/styles.less',
+  'package.json',
+];
+
+async function sha1(filePath) {
+  const content = await readFile(filePath);
+  return crypto
+    .createHash('sha1')
+    .update(content || '')
+    .digest('hex');
+}
+
+async function nextBuildWatcher(context) {
+  // Initialize hashes so that app does not rebuild the first time
+  // Lowdefy build is run.
+  await Promise.all(
+    watchedFiles.map(async (filePath) => {
+      const fullPath = path.resolve(context.directories.server, filePath);
+      hashes[fullPath] = await sha1(fullPath);
+    })
+  );
+
+  const callback = async (filePaths) => {
+    let install = false;
+    let build = false;
+    await Promise.all(
+      filePaths.flat().map(async (filePath) => {
+        const hash = await sha1(filePath);
+        if (hashes[filePath] === hash) {
+          return;
+        }
+        build = true;
+        if (filePath.endsWith('package.json')) {
+          install = true;
+        }
+        hashes[filePath] = hash;
+      })
+    );
+
+    if (!build) {
+      return;
+    }
+
+    context.shutdownServer();
+    if (install) {
+      await context.installPlugins();
+    }
+    await context.nextBuild();
+    context.restartServer();
+  };
+
+  return setupWatcher({
+    callback,
+    watchPaths: [
+      path.join(context.directories.build, 'plugins'),
+      path.join(context.directories.build, 'config.json'),
+      path.join(context.directories.server, 'package.json'),
+    ],
+  });
+}
+
+export default nextBuildWatcher;

package/src/pages/_app.js

@@ -22,12 +22,14 @@ import LowdefyContext from '../components/LowdefyContext.js';
 
 import '../../build/plugins/styles.less';
 
+const lowdefy = {};
+
 function App({ Component, pageProps }) {
   return (
     <ErrorBoundary>
       <Suspense>
-        <LowdefyContext>
-          {(lowdefy) => <Component lowdefy={lowdefy} {...pageProps} />}
+        <LowdefyContext lowdefy={lowdefy}>
+          <Component lowdefy={lowdefy} {...pageProps} />
         </LowdefyContext>
       </Suspense>
     </ErrorBoundary>

package/src/pages/api/reload.js

@@ -14,8 +14,6 @@
   limitations under the License.
 */
 
-// TODO: Send keep-alive comment event: https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#examples
-
 import chokidar from 'chokidar';
 
 const handler = async (req, res) => {

package/src/pages/api/request/[pageId]/[requestId].js

@@ -25,6 +25,7 @@ export default async function handler(req, res) {
       throw new Error('Only POST requests are supported.');
     }
     // TODO: configure API context
+    // TODO: configure build directory?
     const apiContext = await createApiContext({
       buildDirectory: './build',
       connections,

package/src/utils/callRequest.js

@@ -16,9 +16,9 @@
 
 import request from './request.js';
 
-function callRequest({ pageId, payload, requestId }) {
+function callRequest(apiContext, { pageId, payload, requestId }) {
   return request({
-    url: `/api/request/${pageId}/${requestId}`,
+    url: `${apiContext.config.basePath}/api/request/${pageId}/${requestId}`,
     method: 'POST',
     body: { payload },
   });

package/src/utils/setPageId.js

@@ -15,18 +15,18 @@
 */
 
 function setPageId(lowdefy) {
-  if (lowdefy._internal.pathname === '/404') {
+  if (lowdefy._internal.router.pathname === `/404`) {
     lowdefy.pageId = '404';
     return false;
   }
-  if (!lowdefy._internal.query.pageId) {
+  if (!lowdefy._internal.router.query.pageId) {
     lowdefy.pageId = lowdefy.home.pageId;
     if (lowdefy.home.configured === false) {
       return true;
     }
     return false;
   }
-  lowdefy.pageId = lowdefy._internal.query.pageId;
+  lowdefy.pageId = lowdefy._internal.router.query.pageId;
   return false;
 }
 

package/src/utils/setupLink.js

@@ -16,29 +16,37 @@
 
 import { createLink } from '@lowdefy/engine';
 
-function setupLink({ lowdefy }) {
+function setupLink(lowdefy) {
   const { router, window } = lowdefy._internal;
-  const sameOriginLink = (path, newTab) => {
+  const backLink = () => router.back();
+  const disabledLink = () => {};
+  const newOriginLink = ({ url, query, newTab }) => {
     if (newTab) {
-      return window.open(`${window.location.origin}${lowdefy.basePath}${path}`, '_blank').focus();
+      return window.open(`${url}${query ? `?${query}` : ''}`, '_blank').focus();
     } else {
-      // Next handles the basePath here.
-      return router.push({
-        pathname: path,
-        // TODO: Do we handle urlQuery as a param here?
-        // query: {},
-      });
+      return window.location.assign(`${url}${query ? `?${query}` : ''}`);
     }
   };
-  const newOriginLink = (path, newTab) => {
+  const sameOriginLink = ({ newTab, pathname, query, setInput }) => {
     if (newTab) {
-      return window.open(path, '_blank').focus();
+      return window
+        .open(
+          `${window.location.origin}${lowdefy.basePath}${pathname}${query ? `?${query}` : ''}`,
+          '_blank'
+        )
+        .focus();
     } else {
-      return (window.location.href = path);
+      setInput();
+      return router.push({
+        pathname,
+        query,
+      });
     }
   };
-  const backLink = () => window.history.back();
-  return createLink({ backLink, lowdefy, newOriginLink, sameOriginLink });
+  const noLink = () => {
+    throw new Error(`Invalid Link.`);
+  };
+  return createLink({ backLink, disabledLink, lowdefy, newOriginLink, noLink, sameOriginLink });
 }
 
 export default setupLink;

package/src/utils/useMutateCache.js

@@ -16,13 +16,13 @@
 
 import { useSWRConfig } from 'swr';
 
-function useMutateCache() {
+function useMutateCache(basePath) {
   const { cache, mutate } = useSWRConfig();
   return () => {
-    const keys = ['/api/root'];
+    const keys = [`${basePath}/api/root`];
 
     for (const key of cache.keys()) {
-      if (key.startsWith('/api/page')) {
+      if (key.startsWith(`${basePath}/api/page`)) {
         keys.push(key);
       }
     }

package/src/utils/usePageConfig.js

@@ -21,11 +21,8 @@ function fetchPageConfig(url) {
   return request({ url });
 }
 
-function usePageConfig(pageId) {
-  if (!pageId) {
-    pageId = 'NULL';
-  }
-  const { data } = useSWR(`/api/page/${pageId}`, fetchPageConfig, { suspense: true });
+function usePageConfig(pageId, basePath) {
+  const { data } = useSWR(`${basePath}/api/page/${pageId}`, fetchPageConfig, { suspense: true });
   return { data };
 }
 

package/src/utils/useRootConfig.js

@@ -17,12 +17,12 @@ import request from './request.js';
 
 // TODO: Handle TokenExpiredError
 
-function fetchRootConfig() {
-  return request({ url: '/api/root' });
+function fetchRootConfig(url) {
+  return request({ url });
 }
 
-function useRootConfig() {
-  const { data } = useSWR('root', fetchRootConfig, { suspense: true });
+function useRootConfig(basePath) {
+  const { data } = useSWR(`${basePath}/api/root`, fetchRootConfig, { suspense: true });
   return { data };
 }
 

package/src/utils/waitForRestartedServer.js

@@ -20,7 +20,7 @@ function waitForRestartedServer(lowdefy) {
   setTimeout(async () => {
     try {
       await request({
-        url: '/api/ping',
+        url: `${lowdefy.basePath}/api/ping`,
       });
       lowdefy._internal.window.location.reload();
     } catch (error) {