Release 16.1.0

Author: benm071

README.md

@@ -1,12 +1,12 @@
-# @oracle/oraclejet-tooling 16.0.0
+# @oracle/oraclejet-tooling 16.1.0
 
 ## About the tooling API
 This tooling API contains methods to build and serve Oracle JET web apps. It is intended to be used with task running tools such as grunt or gulp. The APIs can also be invoked directly. 
 
 This is an open source project maintained by Oracle Corp.
 
 ## Installation
-This module will be automatically installed when you scaffold a web app following the [Oracle JET Developers Guide](http://www.oracle.com/pls/topic/lookup?ctx=jet1600&id=homepage).
+This module will be automatically installed when you scaffold a web app following the [Oracle JET Developers Guide](http://www.oracle.com/pls/topic/lookup?ctx=jet1610&id=homepage).
 
 ## Contributing
 This project is not accepting external contributions at this time. For bugs or enhancement requests, please file a GitHub issue unless it’s security related. When filing a bug remember that the better written the bug is, the more likely it is to be fixed. If you think you’ve found a security vulnerability, do not raise a GitHub issue and follow the instructions in our [security policy](./SECURITY.md).

RELEASENOTES.md

@@ -1,6 +1,6 @@
 ## Release Notes for oraclejet-tooling ##
 
-### 16.0.0
+### 16.1.0
 
 ### 11.0.0
 * oraclejet-tooling now requires node 12.21 or later

lib/buildCommon/compileTypescript.js

@@ -124,8 +124,10 @@ function _compileComponentTypescript({
     () => _setupTypescriptCompilation(context),
     // run before_component_typescript hook
     () => hookRunner('before_component_typescript', context),
-    // compile component typescript
-    () => _renameIndexFileInMonoPack({ context }),
+    // rename the index files in vcomponents in packs
+    () => _generateStubFile({ context }),
+    // remove the pre-existing type folders if exists
+    () => _removePreExistingTypesFoldersInWeb({ context }),
     // compile component typescript
     () => _runTypescriptCompilation({ context, pack, component }),
     // copy runtime resources to /js
@@ -169,6 +171,12 @@ function _compileComponentTypescript({
       _generateApiDocumentation,
       { context }
     ),
+    // verifies the contents of a built mono-pack
+    () => _runIfTypescriptCompilationSucceeded(
+      context,
+      _verifyMonoPacks,
+      { context }
+    ),
     // deletes declared global block
     () => _runIfTypescriptCompilationSucceeded(
       context,
@@ -238,8 +246,10 @@ function compileApplicationTypescript(context) {
     () => _setupTypescriptCompilation(context),
     // run before_app_typescript hook
     () => hookRunner('before_app_typescript', context),
-    // rename the index files in vcomponents in mono-packs
-    () => _renameIndexFileInMonoPack({ context }),
+    // rename the index files in vcomponents in packs
+    () => _generateStubFile({ context }),
+    // remove the pre-existing type folders if exists
+    () => _removePreExistingTypesFoldersInWeb({ context }),
     // compile app typescript
     () => _runTypescriptCompilation({ context }),
     // copy runtime sources to /js
@@ -266,6 +276,12 @@ function compileApplicationTypescript(context) {
       _organizeComponentsTypeDefinitions,
       { context }
     ),
+    // verifies the contents of a built mono-pack
+    () => _runIfTypescriptCompilationSucceeded(
+      context,
+      _verifyMonoPacks,
+      { context }
+    ),
     // deletes declared global block
     () => _runIfTypescriptCompilationSucceeded(
       context,
@@ -286,49 +302,62 @@ function compileApplicationTypescript(context) {
 }
 
 /**
- * ## _renameIndexFileInMonoPack
+ * ## _generateStubFile
  *
  * renames the vcomponent index.ts file in a mono-pack to <componentName>.ts,
- * and copies it to the mono-pack root level:
+ * and copies it to the pack root level:
  *
  * @private
  * @param {object} context - build context
  */
-function _renameIndexFileInMonoPack({ context }) {
+function _generateStubFile({ context }) {
   const compositeComponents = context.opts.component ? [context.opts.component] :
     util.getLocalCompositeComponents();
   compositeComponents.forEach((compositeComponent) => {
     const componentJson = util.getComponentJson({ component: compositeComponent });
-    if (componentJson.type && componentJson.type === CONSTANTS.PACK_TYPE.MONO_PACK) {
+    if (componentJson.type && (componentJson.type === 'pack' ||
+      componentJson.type === CONSTANTS.PACK_TYPE.MONO_PACK)) {
       const vComponentsInMonoPack = util.getVComponentsInJETPack({ pack: compositeComponent });
+      const useUnversionedStructure = context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ||
+        util.getOraclejetConfigJson().unversioned;
       vComponentsInMonoPack.forEach((vComponent) => {
         const pathToComponentInTsFolder = path.join(
           context.opts.stagingPath,
           'ts',
           context.paths.components,
           compositeComponent,
-          context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ? `${vComponent}` :
+          useUnversionedStructure ? `${vComponent}` :
             path.join(componentJson.version, vComponent)
         );
         const pathToComponentWithoutTsFolder = path.join(
           context.opts.stagingPath,
           context.paths.components,
           compositeComponent,
-          context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ? `${vComponent}` :
+          useUnversionedStructure ? `${vComponent}` :
             path.join(componentJson.version, vComponent)
         );
         const pathToComponentsInWeb = fs.existsSync(pathToComponentInTsFolder) ?
           pathToComponentInTsFolder : pathToComponentWithoutTsFolder;
         const pathToStubFile = `${pathToComponentsInWeb}.ts`;
+        // eslint-disable-next-line no-useless-escape
+        const importMatch = new RegExp(`["|'].\/${vComponent}["|']`);
         const indexFile = path.join(pathToComponentsInWeb, 'index.ts');
-        if (!fs.existsSync(pathToStubFile) && fs.existsSync(indexFile)) {
-          const indexFileContent = fs.readFileSync(indexFile, { encoding: 'utf-8' });
-          // eslint-disable-next-line no-useless-escape
-          const importMatch = new RegExp(`["|'].\/${vComponent}["|']`);
-          fs.writeFileSync(
-            pathToStubFile,
-            indexFileContent.replace(importMatch, `"./${vComponent}/${vComponent}"`)
-          );
+        const loaderFile = path.join(pathToComponentsInWeb, 'loader.ts');
+        if (!fs.existsSync(pathToStubFile)) {
+          if (fs.existsSync(indexFile)) {
+            const indexFileContent = fs.readFileSync(indexFile, { encoding: 'utf-8' });
+            fs.writeFileSync(
+              pathToStubFile,
+              indexFileContent.replace(importMatch, `"${componentJson.name}/${vComponent}/${vComponent}"`)
+            );
+          } else if (fs.existsSync(loaderFile) &&
+            componentJson.type === CONSTANTS.PACK_TYPE.MONO_PACK) {
+            const loaderFileContent = fs.readFileSync(loaderFile, { encoding: 'utf-8' });
+            fs.writeFileSync(
+              pathToStubFile,
+              loaderFileContent.replace(importMatch, `"${componentJson.name}/${vComponent}/${vComponent}"`)
+            );
+          }
         }
       });
     }
@@ -425,7 +454,9 @@ function _runTypescriptCompilation({ context, pack, component }) {
       apiDocDir = null;
     }
     // For component(s) in a pack, the version number is between the pack and component:
-    if (apiDocDir && !context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG]) {
+    const useUnversionedStructure = context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ||
+      util.getOraclejetConfigJson().unversioned;
+    if (apiDocDir && !useUnversionedStructure) {
       if (component && pack) {
         const packVersion = util.getComponentVersion({ component: pack });
         apiDocDir = path.join(components, pack, packVersion, component);
@@ -1223,7 +1254,7 @@ function cleanTypescript(context) {
  *
  * Deletes global declaration for if component's full name is of type any
  *
- * @public
+ * @private
  * @param {object} context
  * @returns {Promise<object>}
  */
@@ -1235,19 +1266,21 @@ function _redefineIndexFileStub({ context }) {
     // Take note that the structure for VDOM apps (where there is no ts/js folders)
     // is observed.
     const componentJson = util.getComponentJson({ component: compositeComponent });
+    const useUnversionedStructure = context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ||
+        util.getOraclejetConfigJson().unversioned;
     const pathToComponent = path.join(
       context.opts.stagingPath,
       util.isVDOMApplication() ? '' : 'ts',
       context.paths.components,
       compositeComponent,
-      context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ? '' : componentJson.version
+      useUnversionedStructure ? '' : componentJson.version
     );
     const pathToComponentInJsFolder = path.join(
       context.opts.stagingPath,
       util.isVDOMApplication() ? '' : 'js',
       context.paths.components,
       compositeComponent,
-      context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ? '' : componentJson.version
+      useUnversionedStructure ? '' : componentJson.version
     );
     if (componentJson.type === 'pack' || componentJson.type === CONSTANTS.PACK_TYPE.MONO_PACK) {
       const vComponentsInMonoPack = util.getVComponentsInJETPack({ pack: compositeComponent });
@@ -1297,6 +1330,15 @@ function _redefineIndexFileStub({ context }) {
   return Promise.resolve(context);
 }
 
+/**
+ * ## _redefineIndexFileStub
+ *
+ * Deletes global declaration for if component's full name is of type any
+ *
+ * @private
+ * @param {string} componentName
+ * @param {array} filePathsArray
+ */
 function _removeGlobalDeclaration(filePathsArray, componentName) {
   filePathsArray.forEach((filePath) => {
     if (fs.existsSync(filePath)) {
@@ -1316,6 +1358,182 @@ function _removeGlobalDeclaration(filePathsArray, componentName) {
   });
 }
 
+/**
+ * ## _verifyMonoPacks
+ *
+ * Verifies the contents of the built mono-packs
+ *
+ * @private
+ * @param {objetc} context
+ */
+function _verifyMonoPacks({ context }) {
+  let compositeComponents;
+
+  if (context && context.opts && context.opts.component) {
+    compositeComponents = [context.opts.component];
+  } else {
+    compositeComponents = util.getLocalCompositeComponents();
+  }
+
+  // Filter the composite components to get packs only:
+  const packArray = compositeComponents.filter(component => util.isJETPack({ pack: component }));
+
+  // Verify each mono-pack in the pack array:
+  packArray.forEach(pack => verifyMonoPack({ pack, context }));
+}
+
+/**
+ * ## verifyMonoPack
+ *
+ * Verifies the contents of a given built-mono-pack
+ *
+ * @param {object} context
+ * @param {string} pack
+ */
+function verifyMonoPack({ pack, context }) {
+  const componentJson = util.getComponentJson({ component: pack });
+  if (componentJson && componentJson.type === CONSTANTS.PACK_TYPE.MONO_PACK) {
+    const packContents = componentJson.contents || [];
+    packContents.forEach((packContent) => {
+      if (util.isLocalComponent({ pack, component: packContent.name })) {
+        verifyComponentsInMonoPack({
+          context,
+          packComponentJson: componentJson,
+          component: packContent.name
+        });
+      } else {
+        verifyOtherContentsInMonoPack({
+          context,
+          packComponentJson: componentJson,
+          packContent
+        });
+      }
+    });
+  }
+}
+
+/**
+ * ## verifyComponentsInMonoPack
+ *
+ * @param {object} context
+ * @param {object} packComponentJson
+ * @param {string} component
+ */
+function verifyComponentsInMonoPack({ context, packComponentJson, component }) {
+  const pack = packComponentJson.name;
+  const version = packComponentJson.version;
+  const componentTypes = ['composite', 'resource', undefined];
+  // At this point, we should have the component json for all components in the
+  // pack; so, we can retrieve it for verification purposes.
+  const componentJson = util.getComponentJson({
+    context,
+    pack,
+    component,
+    built: true
+  });
+
+  // The built component's component json must have a matching name attribute
+  // as that mentioned in the mono-pack's contents name property and the pack
+  // name in the respective component json file matches that of the pack, too:
+  if (componentJson.name !== component) {
+    util.log.error(`Listed component ${component} name does not match`);
+  } else if (!componentJson.pack && componentJson.type !== 'resource') {
+    // It is possible that the pack property in the resource component is not defined:
+    util.log.error(`Component "${component}" does not have a pack property defined in its component.json file.`);
+  } else if (componentJson.pack && componentJson.pack !== pack) {
+    util.log.error(`The name of the pack in "${component}" component json does not match with pack ${pack}`);
+  } else if (!componentTypes.includes(componentJson.type)) {
+    util.log.error(`Component "${component}" has invalid type`);
+  }
+
+  // If the main attribute is present, verify the main value scaffolded is in
+  // the form "main":"<pack>/<component-name>" and that there is a corresponding
+  // physical .js file:
+  if (componentJson.main) {
+    const useUnversionedStructure = context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ||
+    util.getOraclejetConfigJson().unversioned;
+    const pathToStubJsFile = path.join(
+      context.opts.stagingPath,
+      util.isVDOMApplication() ? '' : 'js',
+      context.paths.components,
+      pack,
+      useUnversionedStructure ? '' : version,
+      component,
+      `${component}.js`
+    );
+
+    if (componentJson.main !== `${pack}/${component}`) {
+      util.log.error(`Component ${component} has an invalid main attribute value ${pack}/${component}`);
+    } else if (!fs.existsSync(pathToStubJsFile)) {
+      util.log.error(`Stub file ${component}.js not present at the root of pack ${pack}`);
+    }
+  }
+}
+
+/**
+ * ## verifyOtherContentsInMonoPack
+ *
+ * @param {object} context
+ * @param {object} packComponentJson
+ * @param {object} packContent
+ */
+function verifyOtherContentsInMonoPack({ context, packComponentJson, packContent }) {
+  const pack = packComponentJson.name;
+  const contentName = packContent.name;
+  const version = packComponentJson.version;
+  const contentMainEntry = packContent.main;
+  const useUnversionedStructure = context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ||
+    util.getOraclejetConfigJson().unversioned;
+  const pathToPackInStaging = path.join(
+    context.opts.stagingPath,
+    util.isVDOMApplication() ? '' : 'js',
+    context.paths.components,
+    pack,
+    useUnversionedStructure ? '' : version
+  );
+
+  if (contentMainEntry) {
+    const pathToMainEntryInJsFolder = path.join(pathToPackInStaging, contentMainEntry);
+    if (!fs.existsSync(pathToMainEntryInJsFolder)) {
+      util.log.error(`Content "${contentName}" has a main entry "${contentMainEntry}" that is not in the pack "${pack}".`);
+    }
+  } else {
+    const pathToContentInJsFolder = path.join(pathToPackInStaging, contentName);
+    if (!fs.existsSync(pathToContentInJsFolder)) {
+      util.log.error(`Content "${contentName}" is declared in the content manifest but it is not in the pack "${pack}".`);
+    }
+  }
+}
+
+/**
+ * ## _removePreExistingTypesFoldersInWeb
+ *
+ * Cleans up the pre-existing types before compilation
+ *
+ * @param {object} context
+ */
+function _removePreExistingTypesFoldersInWeb({ context }) {
+  const compositeComponents = context.opts.component ? [context.opts.component] :
+    util.getLocalCompositeComponents();
+  compositeComponents.forEach((compositeComponent) => {
+    const componentJson = util.getComponentJson({ component: compositeComponent });
+    const useUnversionedStructure = context.opts[CONSTANTS.OMIT_COMPONENT_VERSION_FLAG] ||
+      util.getOraclejetConfigJson().unversioned;
+    const pathToComponentTypesFolder = path.join(
+      context.opts.stagingPath,
+      util.isVDOMApplication() ? '' : 'ts',
+      context.paths.components,
+      compositeComponent,
+      useUnversionedStructure ? '' : componentJson.version,
+      'types'
+    );
+    if (fs.existsSync(pathToComponentTypesFolder)) {
+      fs.removeSync(pathToComponentTypesFolder);
+    }
+  });
+  return Promise.resolve(context);
+}
+
 module.exports = {
   compileComponentTypescript,
   compileApplicationTypescript,