piral-cli 0.14.0-unstable.3096 → 0.14.1-beta.3244

package/src/common/package.ts

@@ -7,7 +7,8 @@ import { SourceLanguage, ForceOverwrite } from './enums';
 import { checkAppShellCompatibility } from './compatibility';
 import { deepMerge } from './merge';
 import { getHashFromUrl } from './http';
-import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makeExternals } from './npm';
+import { applyTemplate } from './template';
+import { isGitPackage, isLocalPackage, makeGitUrl, makeFilePath, makePiletExternals, makeExternals } from './npm';
 import { filesTar, filesOnceTar, declarationEntryExtensions } from './constants';
 import { getHash, checkIsDirectory, matchFiles } from './io';
 import { readJson, copy, updateExistingJson, findFile, checkExists } from './io';
@@ -31,6 +32,7 @@ function getDependencyVersion(
 interface FileDescriptor {
   sourcePath: string;
   targetPath: string;
+  template: boolean;
 }
 
 const globPatternStartIndicators = ['*', '?', '[', '!(', '?(', '+(', '@('];
@@ -40,7 +42,12 @@ async function getMatchingFiles(
   target: string,
   file: string | TemplateFileLocation,
 ): Promise<Array<FileDescriptor>> {
-  const { from, to, deep = true } = typeof file === 'string' ? { from: file, to: file, deep: true } : file;
+  const {
+    from,
+    to,
+    deep = true,
+    template = false,
+  } = typeof file === 'string' ? { from: file, to: file, deep: true } : file;
   const sourcePath = resolve(source, from);
   const targetPath = resolve(target, to);
   const isDirectory = await checkIsDirectory(sourcePath);
@@ -52,6 +59,7 @@ async function getMatchingFiles(
     return files.map((file) => ({
       sourcePath: file,
       targetPath: resolve(targetPath, relative(sourcePath, file)),
+      template,
     }));
   } else if (globPatternStartIndicators.some((m) => from.indexOf(m) !== -1)) {
     log('generalDebug_0003', `Matching using glob "${sourcePath}".`);
@@ -73,6 +81,7 @@ async function getMatchingFiles(
     return files.map((file) => ({
       sourcePath: file,
       targetPath: resolve(tarRoot, relative(relRoot, file)),
+      template,
     }));
   }
 
@@ -82,6 +91,7 @@ async function getMatchingFiles(
     {
       sourcePath,
       targetPath,
+      template,
     },
   ];
 }
@@ -174,26 +184,35 @@ export function getPiralPackage(
   };
 }
 
-async function getAvailableFiles(root: string, name: string, tarBall: string): Promise<Array<FileDescriptor>> {
+async function getAvailableFiles(
+  root: string,
+  name: string,
+  dirName: string,
+  fileMap: Array<TemplateFileLocation>,
+): Promise<Array<FileDescriptor>> {
   const source = getPiralPath(root, name);
-  log('generalDebug_0003', `Checking if "files.tar" exists in "${source}" ...`);
-  const exists = await checkExists(resolve(source, `${tarBall}.tar`));
+  const tgz = `${dirName}.tar`;
+  log('generalDebug_0003', `Checking if "${tgz}" exists in "${source}" ...`);
+  const exists = await checkExists(resolve(source, tgz));
 
   if (exists) {
-    await unpackTarball(source, `${tarBall}.tar`);
+    await unpackTarball(source, tgz);
   }
 
   log('generalDebug_0003', `Get matching files from "${source}".`);
-  const base = resolve(source, tarBall);
+  const base = resolve(source, dirName);
   const files = await matchFiles(base, '**/*');
+
   return files.map((file) => ({
     sourcePath: file,
     targetPath: resolve(root, relative(base, file)),
+    template: fileMap.find((m) => resolve(source, m.from) === file)?.template || false,
   }));
 }
 
-export async function getFileStats(root: string, name: string) {
-  const files = await getAvailableFiles(root, name, filesTar);
+export async function getFileStats(root: string, name: string, fileMap: Array<TemplateFileLocation> = []) {
+  const files = await getAvailableFiles(root, name, filesTar, fileMap);
+
   return await Promise.all(
     files.map(async (file) => {
       const { sourcePath, targetPath } = file;
@@ -214,15 +233,20 @@ async function copyFiles(
   subfiles: Array<FileDescriptor>,
   forceOverwrite: ForceOverwrite,
   originalFiles: Array<FileInfo>,
+  variables?: Record<string, string>,
 ) {
   for (const subfile of subfiles) {
-    const { sourcePath, targetPath } = subfile;
+    const { sourcePath, targetPath, template } = subfile;
     const exists = await checkExists(sourcePath);
 
     if (exists) {
       const overwrite = originalFiles.some((m) => m.path === targetPath && !m.changed);
       const force = overwrite ? ForceOverwrite.yes : forceOverwrite;
-      await copy(sourcePath, targetPath, force);
+      const written = await copy(sourcePath, targetPath, force);
+
+      if (written && template && variables) {
+        await applyTemplate(targetPath, variables);
+      }
     } else {
       fail('cannotFindFile_0046', sourcePath);
     }
@@ -234,6 +258,7 @@ export async function copyScaffoldingFiles(
   target: string,
   files: Array<string | TemplateFileLocation>,
   piralInfo?: any,
+  variables?: Record<string, string>,
 ) {
   log('generalDebug_0003', `Copying the scaffolding files ...`);
   const allFiles: Array<FileDescriptor> = [];
@@ -247,7 +272,7 @@ export async function copyScaffoldingFiles(
     await extendPackageOverridesFromTemplateFragment(target, piralInfo, allFiles);
   }
 
-  await copyFiles(allFiles, ForceOverwrite.yes, []);
+  await copyFiles(allFiles, ForceOverwrite.yes, [], variables);
 }
 
 async function extendPackageOverridesFromTemplateFragment(root: string, piralInfo: any, files: Array<FileDescriptor>) {
@@ -276,24 +301,31 @@ async function extendPackageOverridesFromTemplateFragment(root: string, piralInf
   }
 }
 
+function isTemplateFileLocation(item: string | TemplateFileLocation): item is TemplateFileLocation {
+  return typeof item === 'object';
+}
+
 export async function copyPiralFiles(
   root: string,
   name: string,
   piralInfo: any,
   forceOverwrite: ForceOverwrite,
+  variables: Record<string, string>,
   originalFiles?: Array<FileInfo>,
 ) {
   log('generalDebug_0003', `Copying the Piral files ...`);
-  const files = await getAvailableFiles(root, name, filesTar);
+  const { files: _files } = getPiletsInfo(piralInfo);
+  const fileMap = _files.filter(isTemplateFileLocation);
+  const files = await getAvailableFiles(root, name, filesTar, fileMap);
 
   if (originalFiles === undefined) {
-    const initialFiles = await getAvailableFiles(root, name, filesOnceTar);
+    const initialFiles = await getAvailableFiles(root, name, filesOnceTar, fileMap);
     files.push(...initialFiles);
     originalFiles = [];
   }
 
   await extendPackageOverridesFromTemplateFragment(root, piralInfo, files);
-  await copyFiles(files, forceOverwrite, originalFiles);
+  await copyFiles(files, forceOverwrite, originalFiles, variables);
 }
 
 export function getPiletsInfo(piralInfo: any): PiletsInfo {
@@ -410,9 +442,12 @@ export async function retrievePiletsInfo(entryFile: string) {
   }
 
   const packageInfo = require(packageJson);
+  const info = getPiletsInfo(packageInfo);
+  const externals = makeExternals(info.externals);
 
   return {
-    ...getPiletsInfo(packageInfo),
+    ...info,
+    externals,
     name: packageInfo.name,
     version: packageInfo.version,
     dependencies: {
@@ -437,6 +472,7 @@ export async function patchPiletPackage(
   name: string,
   version: string,
   piralInfo: any,
+  fromEmulator: boolean,
   newInfo?: { language: SourceLanguage; bundler: string },
 ) {
   log('generalDebug_0003', `Patching the package.json in "${root}" ...`);
@@ -450,7 +486,6 @@ export async function patchPiletPackage(
     ...piralInfo.dependencies,
   };
   const typeDependencies = newInfo ? getDevDependencies(newInfo.language) : {};
-  const allExternals = makeExternals(externals);
   const scripts = newInfo
     ? {
         start: 'pilet debug',
@@ -460,6 +495,7 @@ export async function patchPiletPackage(
       }
     : info.scripts;
   const peerModules = [];
+  const allExternals = makePiletExternals(externals, fromEmulator, piralInfo);
   const peerDependencies = {
     ...allExternals.reduce((deps, name) => {
       const valid = isValidDependency(name);

package/src/common/scaffold.ts

@@ -93,51 +93,67 @@ function getLanguageName(language: SourceLanguage) {
   }
 }
 
-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));
-  const templatePackageName = getTemplatePackageName('piral', template);
-
-  await createDirectory(src);
-
-  const files = await getTemplateFiles(templatePackageName, registry, root, {
+  return {
     ...variables,
+    root,
     src,
     language: getLanguageName(language),
     packageName,
-  });
-
-  await writeFiles(root, files, forceOverwrite);
+  };
 }
 
-export async function scaffoldPiletSourceFiles(
+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, data);
+
+  await writeFiles(root, files, forceOverwrite);
+}
+
+export function getPiletScaffoldData(
   language: SourceLanguage,
   root: string,
   sourceName: string,
-  forceOverwrite: ForceOverwrite,
   variables: Record<string, string>,
 ) {
   const src = join(root, 'src');
-  const templatePackageName = getTemplatePackageName('pilet', template);
-
-  await createDirectory(src);
-
-  const files = await getTemplateFiles(templatePackageName, registry, root, {
+  return {
     ...variables,
+    root,
     src,
     language: getLanguageName(language),
     sourceName,
-  });
+  };
+}
+
+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, data);
 
   await writeFiles(root, files, forceOverwrite);
 }

package/src/common/template.ts

@@ -1,13 +1,36 @@
 import { renderFile } from 'ejs';
+import { writeFile } from 'fs';
 import { resolve } from 'path';
 import { log } from './log';
 import { ForceOverwrite } from './enums';
 import { createFileIfNotExists } from './io';
 
+export async function applyTemplate(file: string, data: Record<string, string>) {
+  const content = await new Promise<string>((resolve, reject) => {
+    log('generalDebug_0003', `Filling template in "${file}".`);
+    renderFile(file, data, (err, str) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(str);
+      }
+    });
+  });
+  await new Promise<void>((resolve, reject) => {
+    writeFile(file, content, 'utf8', (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
 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}".`);
+    log('generalDebug_0003', `Rendering template "${name}" in "${path}".`);
     renderFile(path, data, (err, str) => {
       if (err) {
         reject(err);

package/src/helpers.ts

@@ -5,7 +5,7 @@ export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'v2', 'none'];
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
 export const buildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
 export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn'];
-export const bundlerKeys: Array<string> = ['none', 'parcel', 'webpack', 'webpack5'];
+export const bundlerKeys: Array<string> = ['none', 'parcel', 'webpack', 'webpack5', 'esbuild'];
 export const availableBundlers: Array<string> = [];
 export const availableReleaseProviders: Array<string> = [];
 export const frameworkKeys: Array<Framework> = ['piral', 'piral-core', 'piral-base'];

package/src/injectors/piral.test.ts

@@ -1,5 +1,6 @@
-import PiralInjector, { PiralInjectorConfig } from './piral';
+import PiralInjector from './piral';
 import { KrasRequest, KrasResult } from 'kras';
+import { EventEmitter } from 'events';
 
 const bundlerMock = {
   pending: true,
@@ -36,7 +37,7 @@ describe('Piral-CLI piral injector', () => {
       bundler,
       active: true,
     };
-    const injector = new PiralInjector(config);
+    const injector = new PiralInjector(config, undefined, new EventEmitter());
     expect(injector.active).toBeTruthy();
   });
 
@@ -46,7 +47,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       active: true,
     };
-    const injector = new PiralInjector(config);
+    const injector = new PiralInjector(config, undefined, new EventEmitter());
 
     // Act
     injector.active = false;
@@ -64,7 +65,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       active: true,
     };
-    const injector = new PiralInjector(config);
+    const injector = new PiralInjector(config, undefined, new EventEmitter());
 
     // Act
     const res = injector.sendResponse('some/nice/invalid/path', 'sometarget.file', 'someDir', 'localhost:1234');
@@ -79,7 +80,7 @@ describe('Piral-CLI piral injector', () => {
       bundler: bundlerMock,
       active: true,
     };
-    const injector = new PiralInjector(config);
+    const injector = new PiralInjector(config, undefined, new EventEmitter());
     const request: KrasRequest = {
       content: 'someFakeContent',
       headers: {},

package/src/injectors/piral.ts

@@ -1,6 +1,7 @@
 import { join } from 'path';
+import { EventEmitter } from 'events';
 import { readFileSync, existsSync, statSync } from 'fs';
-import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig } from 'kras';
+import { KrasInjector, KrasResponse, KrasRequest, KrasInjectorConfig, KrasConfiguration } from 'kras';
 import { mime } from '../external';
 import { Bundler } from '../types';
 
@@ -16,8 +17,26 @@ export interface PiralInjectorConfig extends KrasInjectorConfig {
 export default class PiralInjector implements KrasInjector {
   public config: PiralInjectorConfig;
 
-  constructor(options: PiralInjectorConfig) {
+  constructor(options: PiralInjectorConfig, _config: KrasConfiguration, core: EventEmitter) {
     this.config = options;
+    const api = '/$events';
+    const cbs = {};
+
+    core.on('user-connected', (e) => {
+      if (e.target === '*' && e.url === api.substr(1)) {
+        cbs[e.id] = (msg: string) => e.ws.send(msg);
+      }
+    });
+
+    core.on('user-disconnected', (e) => {
+      delete cbs[e.id];
+    });
+
+    this.config.bundler.on((args) => {
+      for (const id of Object.keys(cbs)) {
+        cbs[id](JSON.stringify(args));
+      }
+    });
   }
 
   get active() {