piral-cli 0.14.0-pre.2983 → 0.14.0-pre.3074

package/src/apps/new-pilet.ts

@@ -120,10 +120,11 @@ export async function newPilet(baseDir = process.cwd(), options: NewPiletOptions
     bundlerName = newPiletDefaults.bundlerName,
     variables = newPiletDefaults.variables,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
   progress('Preparing source and target ...');
-  const root = resolve(baseDir, target);
-  const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(baseDir, source);
+  const [sourceName, sourceVersion, hadVersion, type] = await dissectPackageName(fullBase, source);
   const success = await createDirectory(root);
 
   if (success) {

package/src/apps/new-piral.ts

@@ -118,9 +118,10 @@ export async function newPiral(baseDir = process.cwd(), options: NewPiralOptions
     bundlerName = newPiralDefaults.bundlerName,
     variables = newPiralDefaults.variables,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
   progress('Preparing source and target ...');
-  const root = resolve(baseDir, target);
   const success = await createDirectory(root);
 
   if (success) {

package/src/apps/pack-pilet.ts

@@ -1,3 +1,4 @@
+import { resolve } from 'path';
 import { createPiletPackage, logDone, setLogLevel, progress } from '../common';
 import { LogLevels } from '../types';
 
@@ -30,8 +31,9 @@ export async function packPilet(baseDir = process.cwd(), options: PackPiletOptio
     target = packPiletDefaults.target,
     logLevel = packPiletDefaults.logLevel,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
-  await createPiletPackage(baseDir, source, target);
+  await createPiletPackage(fullBase, source, target);
   logDone(`Pilet packed successfully!`);
 }

package/src/apps/publish-pilet.ts

@@ -1,4 +1,4 @@
-import { relative, join, dirname, basename } from 'path';
+import { relative, join, dirname, basename, resolve } from 'path';
 import { buildPilet } from './build-pilet';
 import { LogLevels, PiletSchemaVersion, PiletPublishSource } from '../types';
 import {
@@ -76,7 +76,7 @@ export const publishPiletDefaults: PublishPiletOptions = {
   fresh: false,
   cert: undefined,
   logLevel: LogLevels.info,
-  schemaVersion: 'v1',
+  schemaVersion: config.schemaVersion,
   from: 'local',
   fields: {},
 };
@@ -134,6 +134,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
     cert = config.cert ?? publishPiletDefaults.cert,
     fields = publishPiletDefaults.fields,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
 
@@ -152,7 +153,7 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
   }
 
   log('generalDebug_0003', 'Getting the tgz files ...');
-  const files = await getFiles(baseDir, source, from, fresh, schemaVersion, ca);
+  const files = await getFiles(fullBase, source, from, fresh, schemaVersion, ca);
   const successfulUploads: Array<string> = [];
   log('generalDebug_0003', 'Received available tgz files.');
 
@@ -164,8 +165,8 @@ export async function publishPilet(baseDir = process.cwd(), options: PublishPile
 
   for (const file of files) {
     log('generalDebug_0003', 'Reading the file for upload ...');
-    const fileName = relative(baseDir, file);
-    const content = await readBinary(baseDir, fileName);
+    const fileName = relative(fullBase, file);
+    const content = await readBinary(fullBase, fileName);
 
     if (content) {
       progress(`Publishing "%s" ...`, file, url);

package/src/apps/publish-piral.ts

@@ -87,6 +87,7 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
     fields = publishPiralDefaults.fields,
     provider = publishPiralDefaults.provider,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
 
   if (type === 'emulator-sources') {
@@ -97,14 +98,14 @@ export async function publishPiral(baseDir = process.cwd(), options: PublishPira
 
   if (type !== 'release') {
     progress('Publishing emulator package ...');
-    await publishEmulator(baseDir, source, fields);
+    await publishEmulator(fullBase, source, fields);
     logDone(`Successfully published emulator.`);
     logReset();
   }
 
   if (type !== 'emulator') {
     progress('Publishing release files ...');
-    await publishRelease(baseDir, source, provider, fields);
+    await publishRelease(fullBase, source, provider, fields);
     logDone(`Successfully published release.`);
     logReset();
   }

package/src/apps/upgrade-pilet.ts

@@ -82,8 +82,9 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
     logLevel = upgradePiletDefaults.logLevel,
     install = upgradePiletDefaults.install,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
-  const root = resolve(baseDir, target);
   const valid = await checkExistingDirectory(root);
 
   if (!valid) {
@@ -107,9 +108,9 @@ export async function upgradePilet(baseDir = process.cwd(), options: UpgradePile
       fail('invalidPiralReference_0043');
     }
 
-    const monorepoRef = await isMonorepoPackageRef(sourceName, baseDir);
+    const monorepoRef = await isMonorepoPackageRef(sourceName, fullBase);
     const [packageRef, packageVersion] = await getCurrentPackageDetails(
-      baseDir,
+      fullBase,
       sourceName,
       currentVersion,
       version,

package/src/apps/upgrade-piral.ts

@@ -81,8 +81,9 @@ export async function upgradePiral(baseDir = process.cwd(), options: UpgradePira
     logLevel = upgradePiralDefaults.logLevel,
     install = upgradePiralDefaults.install,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
+  const root = resolve(fullBase, target);
   setLogLevel(logLevel);
-  const root = resolve(baseDir, target);
   const valid = await checkExistingDirectory(root);
   const exists = await checkExists(join(root, 'package.json'));
 

package/src/apps/validate-pilet.ts

@@ -1,4 +1,4 @@
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { ruleSummary, runRules, retrievePiletData, getPiletsInfo, setLogLevel, progress, log } from '../common';
 import { getPiletRules } from '../rules';
 import { PiletRuleContext, LogLevels } from '../types';
@@ -32,11 +32,12 @@ export async function validatePilet(baseDir = process.cwd(), options: ValidatPil
     logLevel = validatePiletDefaults.logLevel,
     app = validatePiletDefaults.app,
   } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
 
   const rules = await getPiletRules();
-  const entryFile = join(baseDir, entry);
+  const entryFile = join(fullBase, entry);
   const target = dirname(entryFile);
   const {
     dependencies,
@@ -44,6 +45,7 @@ export async function validatePilet(baseDir = process.cwd(), options: ValidatPil
     devDependencies,
     peerModules,
     root,
+    importmap,
     ignored: _0,
     emulator: _1,
     ...data
@@ -63,6 +65,7 @@ export async function validatePilet(baseDir = process.cwd(), options: ValidatPil
     dependencies,
     devDependencies,
     peerDependencies,
+    importmap,
     peerModules,
     root,
     data,

package/src/apps/validate-piral.ts

@@ -1,3 +1,4 @@
+import { resolve } from 'path';
 import { retrievePiralRoot, retrievePiletsInfo, ruleSummary, runRules, config } from '../common';
 import { setLogLevel, progress, log, checkCliCompatibility } from '../common';
 import { getPiralRules } from '../rules';
@@ -22,11 +23,12 @@ export const validatePiralDefaults: ValidatPiralOptions = {
 
 export async function validatePiral(baseDir = process.cwd(), options: ValidatPiralOptions = {}) {
   const { entry = validatePiralDefaults.entry, logLevel = validatePiralDefaults.logLevel } = options;
+  const fullBase = resolve(process.cwd(), baseDir);
   setLogLevel(logLevel);
   progress('Reading configuration ...');
 
   const rules = await getPiralRules();
-  const entryFiles = await retrievePiralRoot(baseDir, entry);
+  const entryFiles = await retrievePiralRoot(fullBase, entry);
   const { root, dependencies, ignored: _, ...info } = await retrievePiletsInfo(entryFiles);
   const errors: Array<string> = [];
   const warnings: Array<string> = [];

package/src/bundler.test.ts

@@ -6,8 +6,8 @@ import {
   callPiralDebug,
   callDebugPiralFromMonoRepo,
 } from './bundler';
+import * as common from './common';
 
-let common: any;
 let defaults = {
   bundler: false,
 };
@@ -29,27 +29,23 @@ jest.mock('./inject', () => ({
   },
 }));
 
-jest.mock(
-  './common',
-  () =>
-    (common = {
-      config: {
-        bundler: 'parcel',
-      },
-      cliVersion: '1.0.0',
-      installPackage: jest.fn(),
-      fail(msg) {
-        throw new Error(msg);
-      },
-      progress() {},
-      log() {},
-      determineNpmClient() {
-        return 'npm';
-      },
-      patchModules: jest.fn(),
-      logReset() {},
-    }),
-);
+jest.mock('./common', () => ({
+  config: {
+    bundler: 'parcel',
+  },
+  cliVersion: '1.0.0',
+  installPackage: jest.fn(),
+  fail(msg) {
+    throw new Error(msg);
+  },
+  progress() {},
+  log() {},
+  determineNpmClient() {
+    return 'npm';
+  },
+  patchModules: jest.fn(),
+  logReset() {},
+}));
 
 describe('Piral CLI Bundler Module', () => {
   it('fails if no default bundler can be installed, but required', async () => {

package/src/common/config.ts

@@ -1,5 +1,5 @@
 import { rc } from '../external';
-import { NpmClientType } from '../types';
+import { NpmClientType, PiletSchemaVersion } from '../types';
 
 export interface PiralCliConfig {
   /**
@@ -37,6 +37,10 @@ export interface PiralCliConfig {
    * Sets the validators configuration for a Piral instance.
    */
   validators?: Record<string, any>;
+  /**
+   * Sets the schema version to be used for pilets.
+   */
+  schemaVersion?: PiletSchemaVersion;
 }
 
 export const config: PiralCliConfig = rc('piral', {
@@ -48,4 +52,5 @@ export const config: PiralCliConfig = rc('piral', {
   bundler: 'webpack',
   piletApi: '/$pilet-api',
   validators: {},
+  schemaVersion: 'v2',
 });

package/src/common/hash.ts

@@ -7,3 +7,8 @@ export function computeHash(content: string | Buffer = '') {
 export function computeMd5(content: string | Buffer = '') {
   return createHash('md5').update(content).digest('hex');
 }
+
+export function computeIntegrity(content: string) {
+  const sum = createHash('sha256').update(content).digest('base64');
+  return `sha256-${sum}`;
+}

package/src/common/http.ts

@@ -4,9 +4,13 @@ import { Stream } from 'stream';
 import { platform, tmpdir } from 'os';
 import { createWriteStream } from 'fs';
 import { log } from './log';
+import { computeHash } from './hash';
 import { axios, FormData } from '../external';
 
 const os = platform();
+const standardHeaders = {
+  'user-agent': `piral-cli/http.node-${os}`,
+};
 
 function getMessage(body: string | { message?: string }) {
   if (typeof body === 'string') {
@@ -36,14 +40,24 @@ function streamToFile(source: Stream, target: string) {
   });
 }
 
+export function getHashFromUrl(target: string): Promise<string> {
+  return axios.default
+    .get<Buffer>(target, {
+      responseType: 'arraybuffer',
+      headers: standardHeaders,
+    })
+    .then((res) => {
+      log('generalDebug_0003', `Received the contents from "${target}" (status: ${res.status}).`);
+      return computeHash(res.data);
+    });
+}
+
 export function downloadFile(target: string, ca?: Buffer): Promise<Array<string>> {
   const httpsAgent = ca ? new Agent({ ca }) : undefined;
   return axios.default
     .get<Stream>(target, {
       responseType: 'stream',
-      headers: {
-        'user-agent': `piral-cli/http.node-${os}`,
-      },
+      headers: standardHeaders,
       httpsAgent,
     })
     .then((res) => {
@@ -80,7 +94,7 @@ export function postFile(
 
   const headers: Record<string, string> = {
     ...form.getHeaders(),
-    'user-agent': `piral-cli/http.node-${os}`,
+    ...standardHeaders,
   };
 
   if (key) {

package/src/common/io.ts

@@ -205,16 +205,22 @@ async function matchAnyPattern(baseDir: string, pattern: AnyPattern) {
 
 const preferences = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs', '.esm', '.es', '.es6', '.html'];
 
-export async function matchAny(baseDir: string, patterns: Array<string>) {
+export async function matchAnyPilet(baseDir: string, patterns: Array<string>) {
   const matches: Array<string> = [];
+  const pilets: Array<string> = [];
+  const matched = (name: string, path: string) => {
+    pilets.push(name);
+    matches.push(path);
+  };
+  const nameOfPackageJson = 'package.json';
   const exts = preferences.map((s) => s.substr(1)).join(',');
   const allPatterns = patterns.reduce<Array<AnyPattern>>((agg, curr) => {
     const patterns = [];
 
-    if (/[a-zA-Z0-9\-]+$/.test(curr) && !preferences.find((ext) => curr.endsWith(ext))) {
-      patterns.push(curr, `${curr}.{${exts}}`, `${curr}/package.json`);
+    if (/[a-zA-Z0-9\-\*]+$/.test(curr) && !preferences.find((ext) => curr.endsWith(ext))) {
+      patterns.push(curr, `${curr}.{${exts}}`, `${curr}/${nameOfPackageJson}`);
     } else if (curr.endsWith('/')) {
-      patterns.push(`${curr}index.{${exts}}`, `${curr}package.json`);
+      patterns.push(`${curr}index.{${exts}}`, `${curr}${nameOfPackageJson}`);
     } else {
       patterns.push(curr);
     }
@@ -227,43 +233,60 @@ export async function matchAny(baseDir: string, patterns: Array<string>) {
     allPatterns.map((patterns) =>
       matchAnyPattern(baseDir, patterns).then(async ({ results, pattern }) => {
         if (!results.length) {
-          //TODO emit warning
+          log('generalDebug_0003', `Found no potential entry points using "${pattern}".`);
         } else {
+          //TODO -> shouldn't take the first one,
+          // should be the first one, yes, but, PER pilet
+          // so that multiple pilets can be considered, too
           log('generalDebug_0003', `Found ${results.length} potential entry points in "${pattern}".`);
-          // only take first / primary result
-          const firstResult = results[0];
-          const fileName = basename(firstResult);
-
-          if (fileName === 'package.json') {
-            log('generalDebug_0003', `Entry point is a "package.json" and needs further inspection.`);
-            const targetDir = dirname(firstResult);
-            const { source } = await readJson(targetDir, fileName);
-
-            if (typeof source === 'string') {
-              log('generalDebug_0003', `Found a "source" field with value "${source}".`);
-              const target = resolve(targetDir, source);
-              const exists = await checkExists(target);
-
-              if (exists) {
-                log('generalDebug_0003', `Taking existing target as "${target}".`);
-                matches.push(target);
-              } else {
-                log('generalDebug_0003', `Source target "${target}" does not exist. Skipped.`);
+
+          for (const result of results) {
+            const fileName = basename(result);
+
+            if (fileName === nameOfPackageJson) {
+              log('generalDebug_0003', `Entry point is a "${nameOfPackageJson}" and needs further inspection.`);
+              const targetDir = dirname(result);
+              const { source, name } = await readJson(targetDir, fileName);
+
+              if (!pilets.includes(name)) {
+                if (typeof source === 'string') {
+                  log('generalDebug_0003', `Found a "source" field with value "${source}".`);
+                  const target = resolve(targetDir, source);
+                  const exists = await checkExists(target);
+  
+                  if (exists) {
+                    log('generalDebug_0003', `Taking existing target as "${target}".`);
+                    matched(name, target);
+                  } else {
+                    log('generalDebug_0003', `Source target "${target}" does not exist. Skipped.`);
+                  }
+                } else {
+                  log('generalDebug_0003', `No "source" field found. Trying combinations in "src".`);
+                  const files = await matchPattern(targetDir, `src/index.{${exts}}`);
+  
+                  if (files.length > 0) {
+                    log('generalDebug_0003', `Found a result; taking "${files[0]}".`);
+                    matched(name, files[0]);
+                  } else {
+                    log('generalDebug_0003', `Found no results in "src". Skipped.`);
+                  }
+                }
               }
             } else {
-              log('generalDebug_0003', `No "source" field found. Trying combinations in "src".`);
-              const files = await matchPattern(baseDir, `src/index.{${exts}}`);
+              const packageJson = await findFile(result, nameOfPackageJson);
+
+              if (packageJson) {
+                const targetDir = dirname(packageJson);
+                const { name } = await readJson(targetDir, nameOfPackageJson);
 
-              if (files.length > 0) {
-                log('generalDebug_0003', `Found a result; taking "${files[0]}".`);
-                matches.push(files[0]);
+                if (!pilets.includes(name)) {
+                  log('generalDebug_0003', `Entry point result is "${result}".`);
+                  matched(name, result);
+                }
               } else {
-                log('generalDebug_0003', `Found no results in "src". Skipped.`);
+                log('generalDebug_0003', `Could not find "${nameOfPackageJson}" for entry "${result}". Skipping.`);
               }
             }
-          } else {
-            log('generalDebug_0003', `Entry point result is "${firstResult}".`);
-            matches.push(firstResult);
           }
         }
       }),