piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/common/parallel.test.ts

@@ -0,0 +1,28 @@
+import { concurrentWorkers } from './parallel';
+
+describe('Concurrent Workers', () => {
+  it('Can run against no entries', async () => {
+    const result = await concurrentWorkers([], 10, () => Promise.resolve('foo'));
+    expect(result).toEqual([]);
+  });
+
+  it('Can run against single entry', async () => {
+    const result = await concurrentWorkers(['bar'], 10, (item) => Promise.resolve('foo' + item));
+    expect(result).toEqual(['foobar']);
+  });
+
+  it('Can run against less entries than concurrency', async () => {
+    const result = await concurrentWorkers(['bar', 'rba', 'abr', 'rab', 'arb', 'bra'], 10, (item) => Promise.resolve('foo' + item));
+    expect(result).toEqual(['foobar', 'foorba', 'fooabr', 'foorab', 'fooarb', 'foobra']);
+  });
+
+  it('Can run against more entries than concurrency', async () => {
+    const result = await concurrentWorkers(['bar', 'rba', 'abr', 'rab', 'arb', 'bra'], 2, (item) => Promise.resolve('foo' + item));
+    expect(result).toEqual(['foobar', 'foorba', 'fooabr', 'foorab', 'fooarb', 'foobra']);
+  });
+
+  it('Can run against equal entries than concurrency', async () => {
+    const result = await concurrentWorkers(['bar', 'rba', 'abr', 'rab', 'arb', 'bra'], 6, (item) => Promise.resolve('foo' + item));
+    expect(result).toEqual(['foobar', 'foorba', 'fooabr', 'foorab', 'fooarb', 'foobra']);
+  });
+});

package/src/common/parallel.ts

@@ -0,0 +1,21 @@
+export async function concurrentWorkers<T, R>(
+  items: Array<T>,
+  concurrency: number,
+  worker: (item: T, index: number) => Promise<R>,
+): Promise<Array<R>> {
+  const maxItems = items.length;
+  const results: Array<R> = new Array(maxItems);
+  let offset = 0;
+
+  await Promise.all(
+    items.slice(0, concurrency).map(async () => {
+      while (offset < maxItems) {
+        const i = offset++;
+        const item = items[i];
+        results[i] = await worker(item, i);
+      }
+    }),
+  );
+
+  return results;
+}

package/src/common/platform.ts

@@ -0,0 +1,31 @@
+import { fail } from './log';
+import { PlatformStartShellOptions, PlatformStartModuleOptions } from '../types';
+
+export interface WebPlatformSettings {
+  platform: 'web';
+}
+
+export interface NodePlatformSettings {
+  platform: 'node';
+}
+
+export type PlatformSettings = WebPlatformSettings | NodePlatformSettings;
+
+export interface PlatformTarget {
+  startShell(options: PlatformStartShellOptions): Promise<void>;
+  startModule(options: PlatformStartModuleOptions): Promise<void>;
+}
+
+export function configurePlatform(target: Partial<PlatformSettings> = {}): PlatformTarget {
+  const { platform = 'web', ...options } = target;
+
+  if (platform === 'web') {
+    const { setup } = require('../platforms/web');
+    return setup(options);
+  } else if (platform === 'node') {
+    const { setup } = require('../platforms/node');
+    return setup(options);
+  }
+
+  return fail('platformNotSupported_0190', platform);
+}

package/src/common/port.test.ts

@@ -4,7 +4,10 @@ const defaultPort = 12345;
 const error = Error('RangeError: Port should be >= 0 and < 65536.');
 
 jest.mock('../external', () => ({
-  getPort: (options: any) => {
+  ora() {
+    return {};
+  },
+  getPort(options: any) {
     if (options == undefined) {
       return Promise.resolve(defaultPort);
     } else if (options && options.port && options.port > 65536) {

package/src/common/port.ts

@@ -1,6 +1,16 @@
 import { log } from './log';
 import { getPort } from '../external';
 
+export async function getAvailablePort(defaultPort: number) {
+  const selectedPort = await getFreePort(defaultPort);
+
+  if (selectedPort !== defaultPort) {
+    log('portNotFree_0047', selectedPort, defaultPort);
+  }
+
+  return selectedPort;
+}
+
 export async function getFreePort(preferred?: number) {
   log('generalDebug_0003', `Looking for a free port. Preferred port: ${preferred}`);
   const port = await getPort(preferred && { port: preferred });

package/src/common/rules.test.ts

@@ -1,5 +1,5 @@
 import { ruleSummary, runRules } from './rules';
-import chalk from 'chalk';
+import { chalk } from '../external';
 
 const rule = {
   run: jest.fn(),
@@ -13,9 +13,9 @@ describe('Rules Module', () => {
     };
     expect(runException).toThrow(Error('[0080] Validation failed. Found 1 error(s).'));
 
-    let consoleSpy = jest.spyOn(console, 'log');
+    let consoleSpy = jest.spyOn(process.stderr, 'write');
     ruleSummary([], []);
-    expect(consoleSpy).toHaveBeenCalledWith(`✨  ${chalk.green.bold('Validation successful. No errors or warnings.')}`);
+    expect(consoleSpy).toHaveBeenLastCalledWith(`${chalk.green('✔')} Validation successful. No errors or warnings.\n`);
 
     jest.clearAllMocks();
     ruleSummary([], ['Warning!']);

package/src/common/scaffold.ts

@@ -1,9 +1,10 @@
-import { join, dirname, resolve, basename } from 'path';
-import { installPackage } from './clients/npm';
-import { ForceOverwrite, SourceLanguage } from './enums';
+import { join, dirname, resolve, basename, isAbsolute } from 'path';
+import { installNpmPackageFromOptionalRegistry } from './npm';
+import { ForceOverwrite } from './enums';
 import { createDirectory, createFileIfNotExists, updateExistingJson } from './io';
-import { log, fail } from './log';
-import { Framework } from '../types';
+import { cliVersion, isWindows } from './info';
+import { log, fail, getLogLevel } from './log';
+import { Framework, SourceLanguage } from '../types';
 
 interface TemplateFile {
   path: string;
@@ -11,8 +12,9 @@ interface TemplateFile {
 }
 
 function getTemplatePackage(templatePackageName: string) {
-  const idx = templatePackageName.indexOf('@');
-  const normalizedName = idx > 0 ? templatePackageName.substr(0, idx) : templatePackageName;
+  const idx = templatePackageName.indexOf('@', 1);
+  const normalizedName =
+    idx > 0 && !isAbsolute(templatePackageName) ? templatePackageName.substring(0, idx) : templatePackageName;
 
   try {
     return require(normalizedName);
@@ -29,14 +31,32 @@ async function getTemplateFiles(
   registry: string,
   root: string,
   data: Record<string, any>,
+  forceOverwrite: ForceOverwrite,
 ): Promise<Array<TemplateFile>> {
-  await installPackage(templatePackageName, __dirname, '--registry', registry);
+  // debug in monorepo such as "../templates/pilet-template-react/lib/index.js"
+  if (templatePackageName.startsWith('.')) {
+    templatePackageName = resolve(process.cwd(), templatePackageName);
+  } else {
+    if (templatePackageName.indexOf('@', 1) === -1) {
+      templatePackageName = `${templatePackageName}@latest`;
+    }
+
+    await installNpmPackageFromOptionalRegistry(templatePackageName, __dirname, registry);
+  }
+
   const templateRunner = getTemplatePackage(templatePackageName);
+  const logLevel = getLogLevel();
+  const details = {
+    forceOverwrite,
+    cliVersion,
+    isWindows,
+    logLevel,
+  };
 
   if (typeof templateRunner === 'function') {
-    return await templateRunner(root, data);
+    return await templateRunner(root, data, details);
   } else if ('default' in templateRunner && typeof templateRunner.default === 'function') {
-    return await templateRunner.default(root, data);
+    return await templateRunner.default(root, data, details);
   } else {
     fail(
       'generalError_0002',
@@ -76,68 +96,76 @@ function writeFiles(root: string, files: Array<TemplateFile>, forceOverwrite: Fo
 }
 
 function getTemplatePackageName(type: 'piral' | 'pilet', template: string) {
-  if (template.indexOf('/') === -1) {
+  if (template.indexOf('/') === -1 && !template.startsWith('.')) {
     return `@smapiot/${type}-template-${template}`;
   }
 
   return template;
 }
 
-function getLanguageName(language: SourceLanguage) {
-  switch (language) {
-    case SourceLanguage.js:
-      return 'js';
-    case SourceLanguage.ts:
-    default:
-      return 'ts';
-  }
-}
-
-export async function scaffoldPiralSourceFiles(
-  template: string,
-  registry: string,
+export function getPiralScaffoldData(
   language: SourceLanguage,
   root: string,
   app: string,
   packageName: Framework,
-  forceOverwrite: ForceOverwrite,
   variables: Record<string, string>,
 ) {
   const src = dirname(join(root, app));
+  return {
+    ...variables,
+    root,
+    src,
+    language,
+    packageName,
+    reactVersion: parseInt(variables.reactVersion) || 18,
+    reactRouterVersion: parseInt(variables.reactRouterVersion) || 5,
+  } as const;
+}
+
+export async function scaffoldPiralSourceFiles(
+  template: string,
+  registry: string,
+  data: ReturnType<typeof getPiralScaffoldData>,
+  forceOverwrite: ForceOverwrite,
+) {
+  const { src, root } = data;
   const templatePackageName = getTemplatePackageName('piral', template);
 
   await createDirectory(src);
 
-  const files = await getTemplateFiles(templatePackageName, registry, root, {
-    ...variables,
-    src,
-    language: getLanguageName(language),
-    packageName,
-  });
+  const files = await getTemplateFiles(templatePackageName, registry, root, data, forceOverwrite);
 
   await writeFiles(root, files, forceOverwrite);
 }
 
-export async function scaffoldPiletSourceFiles(
-  template: string,
-  registry: string,
+export function getPiletScaffoldData(
   language: SourceLanguage,
   root: string,
   sourceName: string,
-  forceOverwrite: ForceOverwrite,
   variables: Record<string, string>,
 ) {
   const src = join(root, 'src');
+  return {
+    ...variables,
+    root,
+    src,
+    language,
+    sourceName,
+  } as const;
+}
+
+export async function scaffoldPiletSourceFiles(
+  template: string,
+  registry: string,
+  data: ReturnType<typeof getPiletScaffoldData>,
+  forceOverwrite: ForceOverwrite,
+) {
+  const { src, root } = data;
   const templatePackageName = getTemplatePackageName('pilet', template);
 
   await createDirectory(src);
 
-  const files = await getTemplateFiles(templatePackageName, registry, root, {
-    ...variables,
-    src,
-    language: getLanguageName(language),
-    sourceName,
-  });
+  const files = await getTemplateFiles(templatePackageName, registry, root, data, forceOverwrite);
 
   await writeFiles(root, files, forceOverwrite);
 }

package/src/common/scripts.ts

@@ -15,11 +15,10 @@ function resolveWinPath(specialFolder: string, subPath: string): string | undefi
 }
 
 export function runScript(script: string, cwd = process.cwd(), output: NodeJS.WritableStream = process.stdout) {
-  const bin = resolve('./node_modules/.bin');
+  const bin = resolve(cwd, './node_modules/.bin');
   const sep = isWindows ? ';' : ':';
   const env = Object.assign({}, process.env);
 
-  env.PATH = `${bin}${sep}${env.PATH}`;
   log('generalDebug_0003', `Running "${script}" in "${cwd}" ("${bin}").`);
 
   if (isWindows) {
@@ -29,11 +28,13 @@ export function runScript(script: string, cwd = process.cwd(), output: NodeJS.Wr
       resolveWinPath('AppData', 'npm'),
       resolveWinPath('ProgramFiles', 'nodejs'),
       resolveWinPath('ProgramFiles(x86)', 'nodejs'),
-      ...env.PATH.split(';'),
+      ...(env.Path || env.PATH || '').split(';'),
     ];
-    env.PATH = newPaths.filter(Boolean).join(sep);
+    env.PATH = newPaths.filter((path) => path && path.length > 0).join(sep);
   }
 
+  env.PATH = `${bin}${sep}${env.PATH}`;
+
   return new Promise<void>((resolve, reject) => {
     const error = new MemoryStream();
     const opt = { end: false };

package/src/common/shell.ts

@@ -0,0 +1,34 @@
+import { progress } from './log';
+import {
+  combinePackageRef,
+  dissectPackageName,
+  getPackageName,
+  getPackageVersion,
+  installNpmPackage,
+  isLinkedPackage,
+} from './npm';
+import { NpmClientType } from '../types';
+
+export async function installPiralInstance(
+  usedSource: string,
+  baseDir: string,
+  rootDir: string,
+  npmClient: NpmClientType,
+): Promise<[name: string, version: string]> {
+  const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, usedSource);
+  const isLocal = isLinkedPackage(sourceName, type, hadVersion, rootDir);
+
+  if (!isLocal) {
+    const packageRef = combinePackageRef(sourceName, sourceVersion, type);
+
+    progress(`Installing npm package %s ...`, packageRef);
+    await installNpmPackage(npmClient, packageRef, rootDir, '--save-dev', '--save-exact');
+  } else {
+    progress(`Using locally available npm package %s ...`, sourceName);
+  }
+
+  const packageName = await getPackageName(rootDir, sourceName, type);
+  const packageVersion = getPackageVersion(hadVersion, sourceName, sourceVersion, type, rootDir);
+
+  return [packageName, packageVersion];
+}

package/src/common/spec.ts

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync, statSync } from 'fs';
+import { computeHash, computeIntegrity } from './hash';
+
+const checkV1 = /^\/\/\s*@pilet\s+v:1\s*\(([A-Za-z0-9\_\:\-]+)\)/;
+const checkV2 = /^\/\/\s*@pilet\s+v:2\s*(?:\(([A-Za-z0-9\_\:\-]+),\s*(.*)\))?/;
+const checkV3 = /^\/\/\s*@pilet\s+v:3\s*(?:\(([A-Za-z0-9\_\:\-]+),\s*(.*)\))?/;
+const isUrl = /^https?:\/\//;
+
+function getDependencies(deps: string, basePath: string) {
+  try {
+    const depMap = JSON.parse(deps);
+
+    if (depMap && typeof depMap === 'object') {
+      return Object.keys(depMap).reduce((obj, depName) => {
+        const depUrl = depMap[depName];
+
+        if (typeof depUrl === 'string') {
+          const url = isUrl.test(depUrl) ? depUrl : `${basePath}${depUrl}`;
+          obj[depName] = url;
+        }
+
+        return obj;
+      }, {});
+    }
+  } catch {}
+
+  return {};
+}
+
+export function getPiletSpecMeta(target: string, basePath: string) {
+  if (existsSync(target) && statSync(target).isFile()) {
+    const content = readFileSync(target, 'utf8');
+
+    if (checkV1.test(content)) {
+      // uses single argument; requireRef (required)
+      const [, requireRef] = checkV1.exec(content);
+      return {
+        spec: 'v1',
+        requireRef,
+        integrity: computeIntegrity(content),
+      };
+    } else if (checkV2.test(content)) {
+      // uses two arguments; requireRef and dependencies as JSON (required)
+      const [, requireRef, plainDependencies] = checkV2.exec(content);
+      return {
+        spec: 'v2',
+        requireRef,
+        dependencies: getDependencies(plainDependencies, basePath),
+      };
+    } else if (checkV3.test(content)) {
+      // uses two arguments; requireRef and dependencies as JSON (required)
+      const [, requireRef, plainDependencies] = checkV3.exec(content);
+      return {
+        spec: 'v3',
+        requireRef,
+        dependencies: getDependencies(plainDependencies, basePath),
+      };
+    } else {
+      // uses no arguments
+      return {
+        spec: 'v0',
+        hash: computeHash(content),
+        noCache: true,
+      };
+    }
+  }
+
+  return {};
+}

package/src/common/template.ts

@@ -1,30 +1,32 @@
-import { renderFile } from 'ejs';
-import { resolve } from 'path';
-import { log } from './log';
 import { ForceOverwrite } from './enums';
 import { createFileIfNotExists } from './io';
 
-export function fillTemplate(name: string, data: any = {}) {
-  const path = resolve(__dirname, '..', '..', 'templates', `${name}.ejs`);
-  return new Promise<string>((resolve, reject) => {
-    log('generalDebug_0003', `Rendering template "{name}" in "${path}".`);
-    renderFile(path, data, (err, str) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(str);
-      }
-    });
-  });
+function fillTemplate(data: any = {}) {
+  return `if (process.env.NODE_ENV === 'test') {
+  // behavior for the test environment, we'll try to make it work
+
+  if (typeof window !== 'undefined') {
+    require('./${data.outFile}');
+    const ctx = window['dbg:piral'];
+    const dependencies = (ctx && ctx.pilets && ctx.pilets.getDependencies({})) || {};
+    module.exports = dependencies['${data.name}'] || {};
+  } else {
+    console.error('Your test environment does not define "window". Please make sure to provide a proper environment.');
+    module.exports = {};
+  }
+} else {
+  // under "normal" circumstances disallow such an import
+  throw new Error("This file should not be included anywhere. Usually, this means you've imported the Piral instance directly.");
+}
+`;
 }
 
-export async function createFileFromTemplateIfNotExists(
-  prefix: string,
+export async function createPiralStubIndexIfNotExists(
   targetDir: string,
   fileName: string,
   forceOverwrite?: ForceOverwrite,
   data?: any,
 ) {
-  const content = await fillTemplate(`${prefix}-${fileName}`, data);
+  const content = fillTemplate(data);
   await createFileIfNotExists(targetDir, fileName, content, forceOverwrite);
 }

package/src/common/url.test.ts

@@ -0,0 +1,28 @@
+import { normalizePublicUrl } from './url';
+
+describe('Url Module', () => {
+  it('normalizePublicUrl always returns at least /', () => {
+    const result = normalizePublicUrl('');
+    expect(result).toBe('/');
+  });
+
+  it('normalizePublicUrl makes URLs end with /', async () => {
+    const result = normalizePublicUrl('/foo');
+    expect(result).toBe('/foo/');
+  });
+
+  it('normalizePublicUrl makes URLs start with /', async () => {
+    const result = normalizePublicUrl('foo/');
+    expect(result).toBe('/foo/');
+  });
+
+  it('normalizePublicUrl makes URLs start and end with /', async () => {
+    const result = normalizePublicUrl('foo');
+    expect(result).toBe('/foo/');
+  });
+
+  it('normalizePublicUrl leaves good URLs as-is', async () => {
+    const result = normalizePublicUrl('/foo/bar/1.2.3/');
+    expect(result).toBe('/foo/bar/1.2.3/');
+  });
+});

package/src/common/url.ts

@@ -0,0 +1,15 @@
+export function normalizePublicUrl(url: string) {
+  if (!url) {
+    return '/';
+  }
+
+  if (!url.endsWith('/')) {
+    url = `${url}/`;
+  }
+
+  if (!url.startsWith('/')) {
+    url = `/${url}`;
+  }
+
+  return url;
+}

package/src/common/utils.ts

@@ -0,0 +1,3 @@
+export function onlyUnique<T>(value: T, index: number, self: Array<T>) {
+  return self.indexOf(value) === index;
+}