@vcmap/plugin-cli 2.0.10 → 2.0.12

package/src/create.js

@@ -2,14 +2,12 @@ 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 tar from 'tar';
 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());
-const exec = util.promisify(childProcess.exec);
+import { DepType, installDeps } from './packageJsonHelpers.js';
+import { updatePeerDependencies } from './update.js';
+import { name, version, promiseExec, getDirname } from './pluginCliHelper.js';
 
 /**
  * @typedef {Object} PluginTemplateOptions
@@ -20,77 +18,120 @@ const exec = util.promisify(childProcess.exec);
  * @property {string} author
  * @property {string} repository
  * @property {string} license
+ * @property {string} template
  * @property {Array<string>} peerDeps
+ * @property {boolean} gitlabCi
  */
 
 /**
- * @enum {number}
- */
-const DepType = {
-  DEP: 1,
-  PEER: 2,
-  DEV: 3,
-};
-
-/**
- * @param {Array<string>} deps
- * @param {DepType} type
+ * @param {string} pluginName
  * @param {string} pluginPath
- * @returns {Promise<void>}
+ * @param {string[]} filter - files or dirs to be extracted
  */
-async function installDeps(deps, type, pluginPath) {
-  let save = '--save';
-  if (type === DepType.PEER) {
-    save = '--save-peer';
-  } else if (type === DepType.DEV) {
-    save = '--save-dev';
+async function downloadAndExtractPluginTar(pluginName, pluginPath, filter = undefined) {
+  const logMsg = filter ? filter.join(', ') : pluginName;
+  logger.spin(`Downloading and extracting ${logMsg}`);
+  const { stdout: packOut, stderr: packErr } = await promiseExec(`npm pack ${pluginName} --quiet`, { cwd: pluginPath });
+  logger.error(packErr);
+
+  const tarName = packOut.trim();
+  const tarPath = path.join(pluginPath, tarName);
+  const extractOptions = {
+    file: tarPath,
+    cwd: pluginPath,
+    strip: 1,
+  };
+  if (filter) {
+    extractOptions.filter = entryPath => filter.some(f => entryPath.includes(f));
   }
-  const installCmd = `npm i ${save} ${deps.join(' ')}`;
-  const { stdout, stderr } = await exec(installCmd, { cwd: pluginPath });
-  logger.log(stdout);
-  logger.error(stderr);
+  await tar.x(extractOptions);
+  await fs.promises.rm(tarPath);
+  logger.success(`Downloaded and extracted template ${logMsg}`);
+  logger.stopSpinner();
 }
 
 /**
- * @param {Array<string>} deps
+ * Copies an existing plugin as template and edits package.json
+ * @param {PluginTemplateOptions} options
  * @param {string} pluginPath
  * @returns {Promise<void>}
  */
-async function setUiPeerDepVersions(deps, pluginPath) {
-  const uiPackageJsonContent = await fs.promises.readFile(
-    path.join(pluginPath, 'node_modules', '@vcmap', 'ui', 'package.json'),
+async function copyPluginTemplate(options, pluginPath) {
+  await downloadAndExtractPluginTar(options.template, pluginPath);
+
+  const pluginPackageJson = JSON.parse((await fs.promises.readFile(path.join(pluginPath, 'package.json'))).toString());
+  const userPackageJson = {
+    name: options.name,
+    version: options.version,
+    description: options.description,
+    author: options.author,
+    license: options.license,
+  };
+  const packageJson = { ...pluginPackageJson, ...userPackageJson };
+  if (options.repository) {
+    packageJson.repository = {
+      url: options.repository,
+    };
+  } else {
+    delete options.repository;
+  }
+
+  const writePackagePromise = fs.promises.writeFile(
+    path.join(pluginPath, 'package.json'),
+    JSON.stringify(packageJson, null, 2),
   );
-  const uiPackageJson = JSON.parse(uiPackageJsonContent);
-  deps.forEach((dep, index) => {
-    if (uiPackageJson.peerDependencies[dep]) {
-      deps[index] = `${dep}@${uiPackageJson.peerDependencies[dep]}`;
+
+  const configJson = JSON.parse((await fs.promises.readFile(path.join(pluginPath, 'config.json'))).toString());
+  configJson.name = options.name;
+
+  const writeConfigPromise = fs.promises.writeFile(
+    path.join(pluginPath, 'config.json'),
+    JSON.stringify(configJson, null, 2),
+  );
+
+  await Promise.all([
+    writePackagePromise,
+    writeConfigPromise,
+  ]);
+  logger.debug('created plugin template');
+
+  try {
+    await updatePeerDependencies(packageJson.peerDependencies, pluginPath);
+    logger.spin('installing dependencies... (this may take a while)');
+    if (packageJson.dependencies) {
+      const deps = Object.entries(packageJson.dependencies)
+        .map(([depName, depVersion]) => `${depName}@${depVersion}`);
+      await installDeps(deps, DepType.DEP, pluginPath);
     }
-  });
+    await installDeps([`${name}@${version}`], DepType.DEV, pluginPath);
+    logger.success('Installed dependencies');
+  } catch (e) {
+    logger.error(e);
+    logger.failure('Failed installing dependencies');
+  }
+  logger.stopSpinner();
 }
 
 /**
+ * Creates a plugin from scratch
  * @param {PluginTemplateOptions} options
+ * @param {string} pluginPath
  */
-async function createPluginTemplate(options) {
-  if (!options.name) {
-    logger.error('please provide a plugin name as input parameter');
-    process.exit(1);
+async function createPluginTemplate(options, pluginPath) {
+  const installVitest = options.scripts && options.scripts.find(script => script.test);
+  if (!installVitest) {
+    options.scripts.push({ test: 'echo "Error: no test specified" && exit 1' });
+  } else {
+    options.scripts.push(
+      { coverage: 'vitest run --coverage' },
+    );
   }
-  logger.info(`creating new plugin: ${options.name}`);
 
-  const pluginPath = path.join(process.cwd(), options.name);
-  if (fs.existsSync(pluginPath)) {
-    logger.error('plugin with the provided name already exists');
-    process.exit(1);
-  }
-
-  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,
     description: options.description,
+    type: 'module',
     main: 'src/index.js',
     scripts: Object.assign({ prepublishOnly: 'vcmplugin build' }, ...options.scripts),
     author: options.author,
@@ -142,6 +183,66 @@ async function createPluginTemplate(options) {
     JSON.stringify(configJson, null, 2),
   );
 
+  await fs.promises.mkdir(path.join(pluginPath, 'src'));
+  logger.debug('created src directory');
+
+  const copyIndexPromise = fs.promises.copyFile(
+    path.join(getDirname(), '..', 'assets', 'index.js'),
+    path.join(pluginPath, 'src', 'index.js'),
+  );
+
+  await Promise.all([
+    writePackagePromise,
+    writeConfigPromise,
+    copyIndexPromise,
+  ]);
+
+  if (installVitest) {
+    logger.debug('setting up test environment');
+    await downloadAndExtractPluginTar('@vcmap/hello-world', pluginPath, ['tests', 'vitest.config.js']);
+  }
+
+  try {
+    const peerDependencies = options.peerDeps.reduce((obj, key) => ({ ...obj, [key]: 'latest' }), {});
+    await updatePeerDependencies(peerDependencies, pluginPath);
+    logger.spin('installing dependencies... (this may take a while)');
+    const devDeps = [`${name}@${version}`];
+    if (installEsLint) {
+      devDeps.push('@vcsuite/eslint-config');
+    }
+    if (installVitest) {
+      devDeps.push('vite', 'vitest', '@vitest/coverage-c8', 'jest-canvas-mock', 'jsdom');
+    }
+    await installDeps(devDeps, DepType.DEV, pluginPath);
+    logger.success('Installed dependencies');
+  } catch (e) {
+    logger.error(e);
+    logger.failure('Failed installing dependencies');
+  }
+  logger.stopSpinner();
+}
+
+/**
+ * Creates a new plugin either by copying a template or from scratch
+ * @param {PluginTemplateOptions} options
+ */
+async function createPlugin(options) {
+  if (!options.name) {
+    logger.error('please provide a plugin name as input parameter');
+    process.exit(1);
+  }
+  logger.debug(`creating new plugin: ${options.name}`);
+
+  const pluginPath = path.join(process.cwd(), options.name);
+  if (fs.existsSync(pluginPath)) {
+    logger.error('plugin with the provided name already exists');
+    process.exit(1);
+  }
+
+  await fs.promises.mkdir(pluginPath);
+  await fs.promises.mkdir(path.join(pluginPath, 'plugin-assets'));
+  logger.debug('created plugin directory');
+
   const writeNpmrcPromise = fs.promises.writeFile(
     path.join(pluginPath, '.npmrc'),
     'registry=https://registry.npmjs.org\n',
@@ -160,49 +261,44 @@ async function createPluginTemplate(options) {
     `# v${options.version}\nDocument features and fixes`,
   );
 
-  await fs.promises.mkdir(path.join(pluginPath, 'src'));
-  logger.debug('created src directory');
-
-  const copyTemplatePromise = fs.promises.cp(
-    path.join(getDirname(), '..', 'assets', 'helloWorld'),
-    pluginPath,
-    { recursive: true },
+  const copyGitIgnorePromise = fs.promises.copyFile(
+    path.join(getDirname(), '..', 'assets', 'gitignore'),
+    path.join(pluginPath, '.gitignore'),
   );
 
   await Promise.all([
-    writePackagePromise,
-    writeConfigPromise,
     writeNpmrcPromise,
     writeReadmePromise,
     writeChangesPromise,
-    copyTemplatePromise,
     writeLicense(options.author, options.license, pluginPath),
+    copyGitIgnorePromise,
   ]);
 
+  if (options.gitlabCi) {
+    await fs.promises.copyFile(
+      path.join(getDirname(), '..', 'assets', '.gitlab-ci.yml'),
+      path.join(pluginPath, '.gitlab-ci.yml'),
+    );
+  }
 
-  logger.spin('installing dependencies... (this may take a while)');
-  try {
-    await installDeps(['@vcmap/ui'], DepType.PEER, pluginPath);
-    await setUiPeerDepVersions(options.peerDeps, pluginPath);
-    await installDeps(options.peerDeps, DepType.PEER, pluginPath);
-    const devDeps = [`${name}@${version}`];
-    if (installEsLint) {
-      devDeps.push('@vcsuite/eslint-config');
-    }
-    await installDeps(devDeps, DepType.DEV, pluginPath);
-    logger.success('installed dependencies');
-  } catch (e) {
-    logger.error(e);
-    logger.failure('installed dependencies');
+  if (options.template) {
+    await copyPluginTemplate(options, pluginPath);
+  } else {
+    await createPluginTemplate(options, pluginPath);
   }
-  logger.stopSpinner();
-  logger.success('created plugin');
+  logger.success(`Created plugin ${options.name}`);
 }
 
 /**
  * @returns {Promise<void>}
  */
 export default async function create() {
+  const templateChoices = [
+    { title: 'no template (basic structure)', value: null },
+    { title: 'hello-world', value: '@vcmap/hello-world' },
+    // to add further templates add a choice here
+  ];
+
   const scriptChoices = [
     { title: 'build', value: { build: 'vcmplugin build' }, selected: true },
     { title: 'pack', value: { pack: 'vcmplugin pack' }, selected: true },
@@ -210,6 +306,7 @@ export default async function create() {
     { title: 'preview', value: { preview: 'vcmplugin preview' }, selected: true },
     { title: 'buildStagingApp', value: { buildStagingApp: 'vcmplugin buildStagingApp' }, selected: true },
     { title: 'lint', value: { lint: 'eslint "{src,tests}/**/*.{js,vue}"' }, selected: true },
+    { title: 'test', value: { test: 'vitest' }, selected: true },
   ];
 
   const peerDependencyChoices = [
@@ -229,7 +326,6 @@ export default async function create() {
         if (!value) {
           return false;
         }
-
         if (fs.existsSync(path.join(process.cwd(), value))) {
           return `Directory ${value} already exists`;
         }
@@ -249,13 +345,6 @@ export default async function create() {
       message: 'Description',
       initial: '',
     },
-    {
-      type: 'multiselect',
-      message: 'Add the following scripts to the package.json.',
-      name: 'scripts',
-      choices: scriptChoices,
-      hint: '- Space to select. Enter to submit',
-    },
     {
       type: 'text',
       name: 'author',
@@ -280,15 +369,37 @@ export default async function create() {
         })),
     },
     {
+      type: 'select',
+      name: 'template',
+      message: 'Choose an existing plugin as template',
+      initial: 0,
+      choices: templateChoices,
+    },
+    {
+      type: (prev, values) => (!values.template ? 'multiselect' : null),
+      message: 'Add the following scripts to the package.json.',
+      name: 'scripts',
+      choices: scriptChoices,
+      hint: '- Space to select. Enter to submit',
+    },
+    {
+      type: (prev, values) => (!values.template ? 'multiselect' : null),
       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',
+      name: 'gitlabCi',
+      message: 'Add gitlab-ci.yml?',
+      initial: false,
+      active: 'yes',
+      inactive: 'no',
+    },
   ];
 
   const answers = await prompts(questions, { onCancel() { process.exit(0); } });
 
-  await createPluginTemplate(answers);
+  await createPlugin(answers);
 }

package/src/hostingHelpers.js

@@ -1,6 +1,4 @@
-import { fileURLToPath, URL } from 'url';
-import { promisify } from 'util';
-import { exec } from 'child_process';
+import { URL } from 'url';
 import https from 'https';
 import http from 'http';
 import fs from 'fs';
@@ -8,6 +6,7 @@ import path from 'path';
 import { logger } from '@vcsuite/cli-logger';
 import { getContext, resolveContext } from './context.js';
 import { getPluginEntry, getPluginName } from './packageJsonHelpers.js';
+import { promiseExec, getDirname } from './pluginCliHelper.js';
 
 /**
  * @typedef {Object} HostingOptions
@@ -17,11 +16,6 @@ import { getPluginEntry, getPluginName } from './packageJsonHelpers.js';
  * @property {boolean} [https]
  */
 
-/**
- * @type {(arg1: string, opt?: Object) => Promise<string>}
- */
-const promiseExec = promisify(exec);
-
 /**
  * @param {...string} pathSegments
  * @returns {string}
@@ -39,13 +33,6 @@ export function checkReservedDirectories() {
     });
 }
 
-/**
- * @returns {string}
- */
-export function getDirname() {
-  return path.dirname(fileURLToPath(import.meta.url));
-}
-
 /**
  * @param {string} stringUrl
  * @param {string} auth
@@ -301,10 +288,14 @@ export function addIndexRoute(app, server, production, hostedVcm, auth) {
 }
 
 /**
- * @param {string} command
+ * @param {string|null} args
+ * @param {string} [command='run']
  * @returns {Promise<string>}
  */
-export function executeUiNpm(command) {
+export function executeUiNpm(args, command = 'run') {
   const mapUiDir = resolveMapUi();
-  return promiseExec(`npm run ${command}`, { cwd: mapUiDir });
+  if (args) {
+    return promiseExec(`npm ${command} ${args}`, { cwd: mapUiDir });
+  }
+  return promiseExec(`npm ${command}`, { cwd: mapUiDir });
 }

package/src/packageJsonHelpers.js

@@ -1,5 +1,7 @@
 import fs from 'fs';
+import { logger } from '@vcsuite/cli-logger';
 import { resolveContext } from './context.js';
+import { promiseExec } from './pluginCliHelper.js';
 
 /** @type {Object|null} */
 let packageJson = null;
@@ -7,7 +9,7 @@ let packageJson = null;
 /**
  * @returns {Promise<Object>}
  */
-async function getPackageJson() {
+export async function getPackageJson() {
   if (!packageJson) {
     const packageJsonFileName = resolveContext('package.json');
     if (!fs.existsSync(packageJsonFileName)) {
@@ -46,3 +48,34 @@ export async function getPluginEntry() {
   return entry;
 }
 
+/**
+ * @enum {number}
+ */
+export const DepType = {
+  DEP: 1,
+  PEER: 2,
+  DEV: 3,
+};
+
+/**
+ * @param {Array<string>} deps
+ * @param {DepType} type
+ * @param {string} pluginPath
+ * @returns {Promise<void>}
+ */
+export async function installDeps(deps, type, pluginPath) {
+  if (deps.length < 1) {
+    return;
+  }
+  let save = '--save';
+  if (type === DepType.PEER) {
+    save = '--save-peer';
+  } else if (type === DepType.DEV) {
+    save = '--save-dev';
+  }
+  const installCmd = `npm i ${save} ${deps.join(' ')}`;
+  logger.debug(installCmd);
+  const { stdout, stderr } = await promiseExec(installCmd, { cwd: pluginPath });
+  logger.log(stdout);
+  logger.error(stderr);
+}

package/src/pluginCliHelper.js

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import childProcess from 'child_process';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { logger } from '@vcsuite/cli-logger';
+import { getContext } from './context.js';
+
+/**
+ * @returns {string}
+ */
+export function getDirname() {
+  return path.dirname(fileURLToPath(import.meta.url));
+}
+
+/**
+ * @type {string} version
+ * @type {string} name
+ */
+export const { version, name } = JSON.parse(fs.readFileSync(path.join(getDirname(), '..', 'package.json')).toString());
+
+/**
+ * @type {(arg1: string) => Promise<string>}
+ */
+export const promiseExec = util.promisify(childProcess.exec);
+
+export async function getVcmConfigJs() {
+  let vcmConfigJs = {};
+  const vcmConfigJsPath = path.resolve(getContext(), 'vcm.config.js');
+  if (!fs.existsSync(vcmConfigJsPath)) {
+    logger.debug(`${vcmConfigJsPath} not existing!`);
+    return vcmConfigJs;
+  }
+  try {
+    vcmConfigJs = await import(pathToFileURL(vcmConfigJsPath));
+    logger.info('Using vcm.config.js found in current project.');
+  } catch (err) {
+    logger.error(err);
+  }
+  return vcmConfigJs;
+}

package/src/preview.js

@@ -10,11 +10,13 @@ import {
   addPluginAssets,
   checkReservedDirectories,
   createConfigJsonReloadPlugin,
-  printVcmapUiVersion, resolveMapUi,
+  printVcmapUiVersion,
+  resolveMapUi,
 } from './hostingHelpers.js';
 import build, { getDefaultConfig, getLibraryPaths } from './build.js';
 import { getContext } from './context.js';
 import setupMapUi from './setupMapUi.js';
+import { getVcmConfigJs } from './pluginCliHelper.js';
 
 /**
  * @typedef {HostingOptions} PreviewOptions
@@ -61,7 +63,7 @@ async function getServerOptions(hostedVcm, https) {
       alias,
     },
     server: {
-      middlewareMode: 'html',
+      middlewareMode: true,
       proxy,
       https,
     },
@@ -73,20 +75,22 @@ async function getServerOptions(hostedVcm, https) {
  * @returns {Promise<void>}
  */
 export default async function preview(options) {
-  if (!options.vcm) {
+  const { default: vcmConfigJs } = await getVcmConfigJs();
+  const mergedOptions = { ...vcmConfigJs, ...options };
+  if (!mergedOptions.vcm) {
     await printVcmapUiVersion();
   }
   checkReservedDirectories();
   await build({ development: false, watch: true });
   const app = express();
   logger.info('Starting preview server...');
-  const server = await createServer(await getServerOptions(options.vcm, options.https));
+  const server = await createServer(await getServerOptions(mergedOptions.vcm, mergedOptions.https));
 
-  addMapConfigRoute(app, options.vcm ? `${options.vcm}/map.config.json` : null, options.auth, options.config, true);
-  addIndexRoute(app, server, true, options.vcm, options.auth);
+  addMapConfigRoute(app, mergedOptions.vcm ? `${mergedOptions.vcm}/map.config.json` : null, mergedOptions.auth, mergedOptions.config, true);
+  addIndexRoute(app, server, true, mergedOptions.vcm, mergedOptions.auth);
   addPluginAssets(app, 'dist');
 
-  if (!options.vcm) {
+  if (!mergedOptions.vcm) {
     logger.spin('compiling preview');
     if (!fs.existsSync(resolveMapUi('plugins', 'node_modules'))) {
       logger.info('Could not detect node_modules in map ui plugins. Assuming map UI not setup');
@@ -98,12 +102,12 @@ export default async function preview(options) {
     logger.info('@vcmap/ui built for preview');
     app.use('/assets', express.static(path.join(getContext(), 'node_modules', '@vcmap', 'ui', 'dist', 'assets')));
     app.use('/plugins', express.static(path.join(getContext(), 'dist', 'plugins')));
-    await addConfigRoute(app, options.auth, options.config, true);
+    await addConfigRoute(app, mergedOptions.auth, mergedOptions.config, true);
   }
 
   app.use(server.middlewares);
 
-  const port = options.port || 5005;
+  const port = mergedOptions.port || 5005;
   await app.listen(port);
   logger.info(`Server running on port ${port}`);
 }