Shared config updates

.changeset/eleven-paws-invite.md

@@ -0,0 +1,8 @@
+---
+'@jpmorganchase/mosaic-core': patch
+'@jpmorganchase/mosaic-plugins': patch
+'@jpmorganchase/mosaic-site': patch
+'@jpmorganchase/mosaic-types': patch
+---
+
+`SharedConfigPlugin` can now apply a shared config to a source that doesn't have one but shares a namespace with 1 that does.

packages/core/src/Source.ts

@@ -113,7 +113,8 @@ export default class Source {
         pageExtensions: this.#pageExtensions,
         ignorePages: this.#ignorePages,
         serialiser: this.serialiser,
-        config: this.config.asReadOnly()
+        config: this.config.asReadOnly(),
+        namespace: this.namespace
       }
     );
     const timeTaken = new Date().getTime() - initTime;
@@ -149,7 +150,8 @@ export default class Source {
       pageExtensions: this.#pageExtensions,
       ignorePages: this.#ignorePages,
       serialiser: this.serialiser,
-      config: this.config.asReadOnly()
+      config: this.config.asReadOnly(),
+      namespace: this.namespace
     });
     const timeTaken = new Date().getTime() - initTime;
     if (timeTaken > 800) {

packages/core/src/worker/Source.worker.ts

@@ -39,7 +39,8 @@ if (isMainThread) {
           config,
           serialiser,
           ignorePages: workerData.ignorePages,
-          pageExtensions: workerData.pageExtensions
+          pageExtensions: workerData.pageExtensions,
+          namespace: workerData.namespace
         })
       ),
       switchMap((pages: Page[]) =>
@@ -58,7 +59,8 @@ if (isMainThread) {
           config,
           ignorePages: workerData.ignorePages,
           pageExtensions: workerData.pageExtensions,
-          serialiser
+          serialiser,
+          namespace: workerData.namespace
         });
         // In the main thread we would freeze the filesystem here, but since we throw it away after sending it to the parent process,
         // we don't bother freezing

packages/plugins/src/SharedConfigPlugin.ts

@@ -43,17 +43,31 @@ export interface SharedConfigPluginOptions {
  * It then exports a JSON file (name: `options.filename`) into each directory with the merged config for that level
  */
 const SharedConfigPlugin: PluginType<SharedConfigPluginPage, SharedConfigPluginOptions> = {
-  async $afterSource(pages, { ignorePages, pageExtensions }) {
+  async $afterSource(pages, { ignorePages, pageExtensions, config, namespace }) {
     const isNonHiddenPage = createPageTest(ignorePages, pageExtensions);
     let finalSharedConfig;
 
-    const indexPagesWithSharedConfig = pages.filter(
+    const indexPages = pages.filter(
       page =>
         path.posix.basename(page.fullPath, path.posix.extname(page.fullPath)) === 'index' &&
-        page.sharedConfig !== undefined &&
         isNonHiddenPage(page.fullPath)
     );
 
+    const indexPagesWithSharedConfig = indexPages.filter(page => page.sharedConfig !== undefined);
+
+    if (indexPagesWithSharedConfig.length === 0 && indexPages.length > 0) {
+      const rootPath = indexPages[0].fullPath;
+      const applyNamespaceSharedConfig = {
+        [`${namespace}~~${rootPath}`]: {
+          paths: indexPages.map(indexPage => indexPage.fullPath),
+          rootPath,
+          namespace
+        }
+      };
+      config.setData({ applyNamespaceSharedConfig });
+      return pages;
+    }
+
     for (const page of indexPagesWithSharedConfig) {
       if (finalSharedConfig === undefined) {
         // first shared config we have found so seed the finalSharedConfig
@@ -113,24 +127,97 @@ const SharedConfigPlugin: PluginType<SharedConfigPluginPage, SharedConfigPluginO
     }
 
     // apply closest shared config
-    let closestSharedConfigIndex = 0;
-    for (const pagePath of indexPagesWithoutConfig) {
-      for (let i = 0; i < sharedConfigFiles.length; i++) {
-        if (isWithin(sharedConfigFiles[i], pagePath)) {
-          closestSharedConfigIndex = i;
+    if (sharedConfigFiles.length > 0) {
+      let closestSharedConfigIndex = 0;
+      for (const pagePath of indexPagesWithoutConfig) {
+        for (let i = 0; i < sharedConfigFiles.length; i++) {
+          if (isWithin(sharedConfigFiles[i], pagePath)) {
+            closestSharedConfigIndex = i;
+          }
         }
+
+        const sharedConfigFile = path.posix.join(
+          path.posix.dirname(String(pagePath)),
+          options.filename
+        );
+
+        const closestSharedConfig = path.posix.resolve(
+          path.dirname(String(pagePath)),
+          sharedConfigFiles[closestSharedConfigIndex]
+        );
+        config.setAliases(closestSharedConfig, [sharedConfigFile]);
       }
+    }
+  },
+  async afterUpdate(mutableFilesystem, { sharedFilesystem, globalConfig, namespace }, options) {
+    const { applyNamespaceSharedConfig } = globalConfig.data;
 
-      const sharedConfigFile = path.posix.join(
-        path.posix.dirname(String(pagePath)),
-        options.filename
-      );
+    if (applyNamespaceSharedConfig === undefined) {
+      // there is no source that exists that has told us it needs to share a namespace shared-config
+      return;
+    }
 
-      const closestSharedConfig = path.posix.resolve(
-        path.dirname(String(pagePath)),
-        sharedConfigFiles[closestSharedConfigIndex]
-      );
-      config.setAliases(closestSharedConfig, [sharedConfigFile]);
+    // find all the entries that match the namespace the plugin is running against
+    const namespaceSharedConfigs: {
+      paths: string[];
+      rootPath: string;
+      namespace: string;
+    }[] = Object.keys(applyNamespaceSharedConfig)
+      .filter(key => {
+        const keyNamespace = key.split('~~')?.[0];
+        return keyNamespace === namespace;
+      })
+      .map(key => applyNamespaceSharedConfig?.[key] || []);
+
+    for (const namespaceSharedConfig of namespaceSharedConfigs) {
+      if (await mutableFilesystem.promises.exists(namespaceSharedConfig.rootPath)) {
+        // a source does need a namespace shared config but the source running this plugin is the source that needs it
+        // so we don't need to do anything here
+        continue;
+      }
+
+      for (const applyPath of namespaceSharedConfig.paths) {
+        if (!(await sharedFilesystem.promises.exists(applyPath))) {
+          sharedFilesystem.promises.mkdir(path.posix.dirname(String(applyPath)), {
+            recursive: true
+          });
+        }
+        let parentDir = path.posix.join(path.posix.dirname(String(applyPath)), '../');
+        let closestSharedConfigPath = path.posix.join(parentDir, options.filename);
+
+        while (parentDir !== path.posix.sep) {
+          // walk up the directories in the path to find the closest shared config file
+          closestSharedConfigPath = path.posix.join(parentDir, options.filename);
+          if (await mutableFilesystem.promises.exists(closestSharedConfigPath)) {
+            break;
+          }
+          parentDir = path.posix.join(path.posix.dirname(String(closestSharedConfigPath)), '../');
+        }
+
+        const aliasSharedConfigPath = path.posix.join(
+          path.posix.dirname(String(applyPath)),
+          options.filename
+        );
+
+        if (
+          (await mutableFilesystem.promises.exists(closestSharedConfigPath)) &&
+          !(await sharedFilesystem.promises.exists(aliasSharedConfigPath))
+        ) {
+          console.log(
+            `[Mosaic][Plugin] Source has no shared config. Root index page is: ${namespaceSharedConfig.rootPath}`
+          );
+          console.log(
+            '[Mosaic][Plugin] Copying shared config ',
+            closestSharedConfigPath,
+            '-->',
+            aliasSharedConfigPath
+          );
+          await sharedFilesystem.promises.writeFile(
+            aliasSharedConfigPath,
+            await mutableFilesystem.promises.readFile(closestSharedConfigPath)
+          );
+        }
+      }
     }
   }
 };