@vcmap/plugin-cli 1.0.0 → 2.0.1

package/src/create.js

@@ -1,11 +1,14 @@
-const fs = require('fs');
-const path = require('path');
-const prompts = require('prompts');
-const semver = require('semver');
-const util = require('util');
-const childProcess = require('child_process');
-const { logger } = require('@vcsuite/cli-logger');
-const { version } = require('../package.json');
+import fs from 'fs';
+import path from 'path';
+import prompts from 'prompts';
+import semver from 'semver';
+import util from 'util';
+import childProcess from 'child_process';
+import { logger } from '@vcsuite/cli-logger';
+import { LicenseType, writeLicense } from './licenses.js';
+import { getDirname } from './hostingHelpers.js';
+
+export const { version, name } = JSON.parse(fs.readFileSync(path.join(getDirname(), '..', 'package.json')).toString());
 
 /**
  * @typedef {Object} PluginTemplateOptions
@@ -17,6 +20,7 @@ const { version } = require('../package.json');
  * @property {string} license
  * @property {string} mapVersion
  * @property {boolean} addDevDep
+ * @property {Array<string>} peerDeps
  */
 
 /**
@@ -36,8 +40,8 @@ async function createPluginTemplate(options) {
   }
 
   await fs.promises.mkdir(pluginPath);
+  await fs.promises.mkdir(path.join(pluginPath, 'plugin-assets'));
   logger.debug('created plugin directory');
-
   const packageJson = {
     name: options.name,
     version: options.version,
@@ -50,7 +54,7 @@ async function createPluginTemplate(options) {
       vcm: options.mapVersion,
     },
     dependencies: {},
-    devDependencies: options.addDevDep ? { 'vcmplugin-cli': `^${version}` } : {},
+    devDependencies: options.addDevDep ? { [name]: `^${version}` } : {}, // XXX should we add all our deps here? cesium, ol, vue etc.
   };
 
   const writePackagePromise = fs.promises.writeFile(
@@ -60,7 +64,6 @@ async function createPluginTemplate(options) {
 
   const configJson = {
     name: options.name,
-    version: options.version,
   };
 
   const writeConfigPromise = fs.promises.writeFile(
@@ -81,23 +84,43 @@ async function createPluginTemplate(options) {
 
   const writeIndexPromise = fs.promises.writeFile(
     path.join(pluginPath, 'src', 'index.js'),
-    ['import { version } from \'../package.json\';',
+    [
+      'import { version, name } from \'../package.json\';',
+      '',
+      '/**',
+      ' * @param {VcsApp} app - the app from which this plugin is loaded.',
+      ' * @param {Object} config - the configuration of this plugin instance, passed in from the app.',
+      ' */',
+      'export default function(app, config) {',
+      '  return {',
+      '    get name() { return name; },',
+      '    get version() { return version; },',
+      '    initialize: async (vcsUiApp) => { console.log(\'Called before loading the rest of the current context. Passed in the containing Vcs UI App \'); },',
+      '    onVcsAppMounted: async (vcsUiApp) => { console.log(\'Called when the root UI component is mounted and managers are ready to accept components\'); },',
+      '    toJSON: async () => { console.log(\'Called when serializing this plugin instance\'); },',
+      '  };',
+      '};',
       '',
-      'export default {',
-      '  version,',
-      '  // preInitialize',
-      '  // postInitialize',
-      '  // registerUiPlugin',
-      '  // postUiInitialize',
-      '};'].join('\n'),
+    ].join('\n'),
   );
 
-  await Promise.all([writePackagePromise, writeConfigPromise, writeReadmePromise, writeIndexPromise]);
+  await Promise.all([
+    writePackagePromise,
+    writeConfigPromise,
+    writeReadmePromise,
+    writeIndexPromise,
+    writeLicense(options.author, options.license, pluginPath),
+  ]);
+
 
-  logger.spin('installing dependencies...');
+  logger.spin('installing dependencies... (this may take a while)');
   const exec = util.promisify(childProcess.exec);
   try {
-    const { stdout, stderr } = await exec('npm i', { cwd: pluginPath });
+    let installCmd = 'npm i';
+    if (options.peerDeps.length > 0) {
+      installCmd = `${installCmd} --save-peer ${options.peerDeps.join(' ')}`;
+    }
+    const { stdout, stderr } = await exec(installCmd, { cwd: pluginPath });
     logger.log(stdout);
     logger.error(stderr);
     logger.success('installed dependencies');
@@ -112,19 +135,39 @@ async function createPluginTemplate(options) {
 /**
  * @returns {Promise<void>}
  */
-async function create() {
+export default async function create() {
   const scriptChoices = [
     { title: 'build', value: { build: 'vcmplugin build' } },
     { title: 'pack', value: { pack: 'vcmplugin pack' } },
+    { title: 'start', value: { start: 'vcmplugin serve' } },
+    { title: 'preview', value: { preview: 'vcmplugin preview' } },
     { title: 'test', value: { test: 'echo "Error: no test specified" && exit 1' } },
   ];
 
+  const peerDependencyChoices = [
+    { title: '@vcmap/ui', value: '@vcmap/ui', selected: true },
+    { title: '@vcsuite/ui-components', value: '@vcsuite/ui-components', selected: true },
+    { title: '@vcmap/core', value: '@vcmap/core' },
+    { title: '@vcmap/cesium', value: '@vcmap/cesium' },
+    { title: 'ol', value: 'ol@~6.13.0' },
+    { title: '@vue/composition-api', value: '@vue/composition-api@~1.4.5' },
+  ];
+
   const questions = [
     {
       type: 'text',
       name: 'name',
       message: 'Name',
-      validate: value => !!value,
+      validate: (value) => {
+        if (!value) {
+          return false;
+        }
+
+        if (fs.existsSync(path.join(process.cwd(), value))) {
+          return `Directory ${value} already exists`;
+        }
+        return true;
+      },
     },
     {
       type: 'text',
@@ -153,16 +196,28 @@ async function create() {
       initial: 'author <email>',
     },
     {
-      type: 'text',
+      type: 'select',
       name: 'license',
       message: 'License',
-      initial: 'ISC',
+      initial: 0,
+      choices: Object.values(LicenseType)
+        .map(type => ({
+          title: type,
+          value: type,
+        })),
     },
     {
       type: 'text',
       name: 'mapVersion',
       message: 'Map version',
-      initial: '>=4.0',
+      initial: '>=5.0',
+    },
+    {
+      name: 'peerDeps',
+      type: 'multiselect',
+      message: 'Add the following peer dependencies to the package.json.',
+      choices: peerDependencyChoices,
+      hint: '- Space to select. Enter to submit',
     },
     {
       type: 'toggle',
@@ -178,5 +233,3 @@ async function create() {
 
   await createPluginTemplate(answers);
 }
-
-module.exports = create;

package/src/defaultCommand.js

@@ -1,19 +1,37 @@
-const { Command } = require('commander');
+import { Command } from 'commander';
+import { logger } from '@vcsuite/cli-logger';
+import { setContext } from './context.js';
 
 Command.prototype.defaultOptions = function defaultOptions() {
   this
-    .option('-n, --plugin-name [name]', 'a name override to use. extracts the name from the package.json by default')
-    .option('--no-condense-whitespace', 'do not condense white space')
-    .option('-e, --entry <entry>', 'entrypoint override');
+    .option('--context [path]', 'an optional context, default is cwd', (value) => {
+      setContext(value);
+      return value;
+    });
 
   return this;
 };
 
-Command.prototype.defaultBuildOptions = function defaultBuildOptions() {
+Command.prototype.defaultServeOptions = function defaultServeOptions() {
   this
-    .defaultOptions()
-    .option('-l, --library [name]', 'whether to create a library with [name] or not')
-    .option('--library-target [target]', 'library target', 'commonjs2');
+    .option('-p, --port [port]', 'the port to listen on', /\d+/)
+    .option('--auth <user:password>', 'an optional auth to append to proxy requests')
+    .option('-c, --config <config>', 'a config override to not use the default plugin config')
+    .option('--https', 'use https for serving');
 
   return this;
 };
+
+Command.prototype.safeAction = function safeAction(action) {
+  this.action(async (options) => {
+    try {
+      await action(options);
+    } catch (e) {
+      if (e) {
+        logger.error(e);
+      }
+      logger.stopSpinner();
+      process.exit(1);
+    }
+  });
+};

package/src/hostingHelpers.js

@@ -0,0 +1,226 @@
+import { fileURLToPath, URL } from 'url';
+import https from 'https';
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { logger } from '@vcsuite/cli-logger';
+import { getContext, resolveContext } from './context.js';
+import { getPluginEntry, getPluginName } from './packageJsonHelpers.js';
+
+/**
+ * @typedef {Object} HostingOptions
+ * @property {string} [config] - an optional fileName to use for configuring the plugin
+ * @property {string} [auth] - potential auth string to download assets (index.html, config) with
+ * @property {number} [port]
+ * @property {boolean} [https]
+ */
+
+export function checkReservedDirectories() {
+  ['assets', 'plugins']
+    .forEach((dir) => {
+      if (fs.existsSync(path.join(getContext(), dir))) {
+        logger.warning(`found reserved directory ${dir}. serving my not work as exptected`);
+      }
+    });
+}
+
+/**
+ * @returns {string}
+ */
+export function getDirname() {
+  return path.dirname(fileURLToPath(import.meta.url));
+}
+
+/**
+ * @param {string} stringUrl
+ * @param {string} auth
+ * @param {function(http.IncomingMessage)} handler
+ */
+export function httpGet(stringUrl, auth, handler) {
+  const url = new URL(stringUrl);
+  const options = {
+    hostname: url.hostname,
+    port: url.port,
+    path: url.pathname,
+  };
+
+  if (auth) {
+    options.headers = { Authorization: `Basic ${Buffer.from(auth).toString('base64')}` };
+  }
+  if (url.protocol === 'https:') {
+    https.get(options, handler);
+  } else {
+    http.get(options, handler);
+  }
+}
+
+/**
+ * @param {string} fileName
+ * @returns {Promise<Object>}
+ */
+export async function readConfigJson(fileName) {
+  const configFileName = fileName || resolveContext('config.json');
+  let config = {};
+  if (fs.existsSync(configFileName)) {
+    const content = await fs.promises.readFile(configFileName);
+    config = JSON.parse(content.toString());
+  }
+
+  return config;
+}
+
+let configJson = null;
+
+/**
+ * @returns {Promise<string>}
+ */
+export async function printVcmapUiVersion() {
+  const packageJsonPath = path.join(getContext(), 'node_modules', '@vcmap', 'ui', 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error(`Cannot find the @vcmap/ui package in ${getContext()}. Are you sure you installed it?`);
+  }
+
+  const content = await fs.promises.readFile(packageJsonPath);
+  const { version } = JSON.parse(content.toString());
+  logger.info(`Using @vcmap/ui version: ${version} found in current project.`);
+}
+
+/**
+ * @param {string} [mapConfig] - fs or https to config. defaults to @vcmap/ui/map.config.json
+ * @param {string} [auth]
+ * @param {boolean} [production]
+ * @param {string} [configFile]
+ * @returns {Promise<unknown>}
+ */
+export function getConfigJson(mapConfig, auth, production, configFile) {
+  const usedConfig = mapConfig || path.join(getContext(), 'node_modules', '@vcmap', 'ui', 'dist', 'config', 'base.config.json');
+  if (configJson) {
+    return Promise.resolve(configJson);
+  }
+  const isWebVcm = /^https?:\/\//.test(usedConfig);
+  return new Promise((resolve, reject) => {
+    function handleStream(stream) {
+      let data = '';
+      stream.on('data', (chunk) => {
+        data += chunk.toString();
+      });
+
+      stream.on('close', async () => {
+        try {
+          configJson = JSON.parse(data);
+          configJson.plugins = production && configJson.plugins ? configJson.plugins : [];
+          const pluginConfig = await readConfigJson(configFile);
+          pluginConfig.entry = production ? 'dist/index.js' : await getPluginEntry();
+          pluginConfig.name = await getPluginName();
+          const idx = configJson.plugins.findIndex(p => p.name === pluginConfig.name);
+          if (idx > -1) {
+            configJson.plugins.splice(idx, 1, pluginConfig);
+          } else {
+            configJson.plugins.push(pluginConfig);
+          }
+          resolve(configJson);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }
+    if (isWebVcm) {
+      httpGet(usedConfig, auth, (res) => {
+        if (res.statusCode < 400) {
+          handleStream(res);
+        }
+      });
+    } else {
+      handleStream(fs.createReadStream(path.join(usedConfig)));
+    }
+  });
+}
+
+/**
+ * @param {string} stringUrl
+ * @param {string} auth
+ * @returns {Promise<string>}
+ */
+function getIndexHtml(stringUrl, auth) {
+  return new Promise((resolve, reject) => {
+    httpGet(stringUrl, auth, (res) => {
+      let index = '';
+      if (res.statusCode >= 400) {
+        logger.error('got status code: ', res.statusCode);
+        reject(new Error(`StatusCode ${res.statusCode}`));
+      }
+      res.on('data', (chunk) => {
+        index += chunk.toString();
+      });
+      res.on('end', () => {
+        resolve(index);
+      });
+    });
+  });
+}
+
+/**
+ * @returns {import("vite").Plugin}
+ */
+export function createConfigJsonReloadPlugin() {
+  return {
+    name: 'ConfigJsonReload',
+    handleHotUpdate({ file }) {
+      if (file === path.join(getContext(), 'config.json')) {
+        configJson = null;
+      }
+    },
+  };
+}
+
+/**
+ * @param {Express} app
+ * @param {string} mapConfig
+ * @param {string} [auth]
+ * @param {string} [configFile]
+ * @param {boolean} [production]
+ */
+export function addMapConfigRoute(app, mapConfig, auth, configFile, production) {
+  app.get('/map.config.json', (req, res) => {
+    getConfigJson(mapConfig, auth, production, configFile)
+      .then((config) => {
+        const stringConfig = JSON.stringify(config, null, 2);
+        res.setHeader('Content-Type', 'application/json');
+        res.write(stringConfig);
+        res.end();
+      });
+  });
+}
+
+/**
+ * @param {boolean} [production]
+ * @returns {Promise<string>}
+ */
+export async function getMapUiIndexHtml(production) {
+  const indexHtmlFileName = production ?
+    path.join(getContext(), 'node_modules', '@vcmap', 'ui', 'dist', 'index.html') :
+    path.join(getDirname(), '..', 'assets', 'index.html');
+  const buffer = await fs.promises.readFile(indexHtmlFileName);
+  return buffer.toString();
+}
+
+/**
+ * @param {Express} app
+ * @param {import("vite").ViteDevServer} server
+ * @param {boolean} [production]
+ * @param {string} [hostedVcm]
+ * @param {string} [auth]
+ */
+export function addIndexRoute(app, server, production, hostedVcm, auth) {
+  app.get('/', async (req, res) => {
+    let originalIndex = hostedVcm ?
+      await getIndexHtml(`${hostedVcm}/`, auth) :
+      await getMapUiIndexHtml(production); // TODO change hosted vcm index via option?
+
+    originalIndex = await server.transformIndexHtml('index.html', originalIndex);
+    res.status(200)
+      .set({ 'Content-Type': 'text/html' })
+      .end(originalIndex);
+  });
+}
+

package/src/licenses.js

@@ -0,0 +1,128 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * @param {string} user
+ * @param {number} year
+ * @returns {string}
+ */
+function mit(user, year) {
+  return `
+Copyright ${year} ${user}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated 
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
+THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS 
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+`;
+}
+
+/**
+ * @param {string} user
+ * @param {number} year
+ * @returns {string}
+ */
+function apache(user, year) {
+  return `
+Copyright ${year} ${user}
+
+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.
+`;
+}
+
+/**
+ * @param {string} user
+ * @param {number} year
+ * @returns {string}
+ */
+function gpl3(user, year) {
+  return `
+Copyright (C) ${year} ${user}
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+`;
+}
+
+/**
+ * @param {string} user
+ * @param {number} year
+ * @returns {string}
+ */
+function isc(user, year) {
+  return `
+Copyright (c) ${year}, ${user}
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+`;
+}
+
+/**
+ * @enum {string}
+ */
+export const LicenseType = {
+  MIT: 'MIT',
+  ISC: 'ISC',
+  'APACHE-2.0': 'APACHE-2.0',
+  'GPL-3.0': 'GPL-3.0',
+};
+
+/**
+ * @type {Object<LicenseType, function(string, number):string>}
+ */
+const LicenseTypeFunctions = {
+  [LicenseType.MIT]: mit,
+  [LicenseType['GPL-3.0']]: gpl3,
+  [LicenseType.ISC]: isc,
+  [LicenseType['APACHE-2.0']]: apache,
+};
+
+/**
+ * @param {string} user
+ * @param {LicenseType} type
+ * @param {string} pluginPath
+ * @returns {Promise<void>}
+ */
+export function writeLicense(user, type, pluginPath) {
+  const year = new Date().getFullYear();
+  const text = LicenseTypeFunctions[type](user, year);
+
+  return fs.promises.writeFile(path.join(pluginPath, 'LICENSE.md'), text);
+}