apostrophe 3.16.0 → 3.17.0

package/modules/@apostrophecms/asset/lib/webpack/src/webpack.config.js

@@ -2,6 +2,7 @@ const path = require('path');
 const merge = require('webpack-merge').merge;
 const scssTask = require('./webpack.scss');
 const es5Task = require('./webpack.es5');
+const srcBuildNames = [ 'src-build', 'src-es5-build' ];
 
 let BundleAnalyzerPlugin;
 
@@ -10,9 +11,11 @@ if (process.env.APOS_BUNDLE_ANALYZER) {
 }
 
 module.exports = ({
-  importFile, modulesDir, outputPath, outputFilename, es5
+  importFile, modulesDir, outputPath, outputFilename, bundles = {}, es5
 }, apos) => {
+  const mainBundleName = outputFilename.replace('.js', '');
   const taskFns = [ scssTask ];
+
   if (es5) {
     taskFns.push(es5Task);
   }
@@ -20,16 +23,20 @@ module.exports = ({
     task(
       {
         importFile,
-        modulesDir,
-        outputFilename
+        modulesDir
       },
-      apos
+      apos,
+      srcBuildNames
     )
   );
 
-  let config = {
-    entry: importFile,
-    target: es5 ? 'es5' : 'web',
+  const moduleName = es5 ? 'nomodule' : 'module';
+  const config = {
+    entry: {
+      [mainBundleName]: importFile,
+      ...bundles
+    },
+    target: es5 ? [ 'web', 'es5' ] : 'web',
     mode: process.env.NODE_ENV || 'development',
     optimization: {
       minimize: process.env.NODE_ENV === 'production'
@@ -37,11 +44,17 @@ module.exports = ({
     devtool: 'source-map',
     output: {
       path: outputPath,
-      filename: outputFilename
+      filename: ({ chunk }) => {
+        return srcBuildNames.includes(chunk.name)
+          ? '[name].js'
+          : `[name]-${moduleName}-bundle.js`;
+      }
     },
     resolveLoader: {
       extensions: [ '*', '.js' ],
-      modules: [ 'node_modules' ]
+      // Make sure css-loader and postcss-loader can always be found, even
+      // if npm didn't hoist them
+      modules: [ 'node_modules', 'node_modules/apostrophe/node_modules' ]
     },
     resolve: {
       extensions: [ '*', '.js' ],
@@ -50,16 +63,21 @@ module.exports = ({
         Modules: path.resolve(modulesDir)
       },
       modules: [
+        'node_modules',
         `${apos.npmRootDir}/node_modules`,
         // Make sure core-js and regenerator-runtime can always be found, even
         // if npm didn't hoist them
         `${apos.npmRootDir}/node_modules/apostrophe/node_modules`
-      ]
+      ],
+      symlinks: false
     },
     stats: 'verbose',
     plugins: process.env.APOS_BUNDLE_ANALYZER ? [ new BundleAnalyzerPlugin() ] : []
   };
 
-  config = merge(config, ...tasks);
-  return config;
+  if (es5) {
+    config.output.chunkFormat = 'array-push';
+  }
+
+  return merge(config, ...tasks);
 };

package/modules/@apostrophecms/asset/lib/webpack/src/webpack.es5.js

@@ -1,6 +1,6 @@
 module.exports = (options, apos) => {
   return {
-    target: 'es5',
+    target: [ 'web', 'es5' ],
     module: {
       rules: [
         {

package/modules/@apostrophecms/asset/lib/webpack/src/webpack.scss.js

@@ -1,6 +1,6 @@
 const MiniCssExtractPlugin = require('mini-css-extract-plugin');
 
-module.exports = (options, apos) => {
+module.exports = (options, apos, srcBuildNames) => {
   return {
     module: {
       rules: [
@@ -40,7 +40,11 @@ module.exports = (options, apos) => {
     plugins: [
       new MiniCssExtractPlugin({
         // Should be automatic but we wind up with main.css if we try to go with that
-        filename: options.outputFilename.replace('.js', '.css')
+        filename: ({ chunk }) => {
+          return srcBuildNames.includes(chunk.name)
+            ? '[name].css'
+            : '[name]-bundle.css';
+        }
       })
     ]
   };

package/modules/@apostrophecms/asset/lib/webpack/utils.js

@@ -0,0 +1,266 @@
+const fs = require('fs-extra');
+
+module.exports = {
+  checkModulesWebpackConfig(modules, t) {
+    const allowedProperties = [ 'extensions', 'bundles' ];
+    for (const mod of Object.values(modules)) {
+      const webpackConfig = mod.__meta.webpack[mod.__meta.name];
+
+      if (!webpackConfig) {
+        continue;
+      }
+
+      if (
+        typeof webpackConfig !== 'object' ||
+        webpackConfig === null ||
+        Array.isArray(webpackConfig) ||
+        Object.keys(webpackConfig).some((prop) => !allowedProperties.includes(prop))
+      ) {
+        const error = t('apostrophe:assetWebpackConfigWarning', {
+          module: mod.__meta.name
+        });
+
+        throw new Error(error);
+      }
+
+      if (webpackConfig && webpackConfig.bundles) {
+        const bundles = Object.values(webpackConfig.bundles);
+
+        bundles.forEach(bundle => {
+          const bundleProps = Object.keys(bundle);
+          if (
+            bundleProps.length > 1 ||
+            (bundleProps.length === 1 && !bundle.templates) ||
+            (bundle.templates && !Array.isArray(bundle.templates))
+          ) {
+            const error = t('apostrophe:assetWebpackBundlesWarning', {
+              module: mod.__meta.name
+            });
+
+            throw new Error(error);
+          }
+        });
+      }
+    }
+  },
+
+  async getWebpackExtensions ({
+    getMetadata, modulesToInstantiate
+  }) {
+    const modulesMeta = modulesToInstantiate
+      .map((name) => getMetadata(name));
+
+    const { extensions, foundBundles } = getModulesWebpackConfigs(
+      modulesMeta
+    );
+
+    const verifiedBundles = await verifyBundlesEntryPoints(foundBundles);
+
+    return {
+      extensions,
+      verifiedBundles
+    };
+  },
+
+  fillExtraBundles (verifiedBundles = {}) {
+    return Object.entries(verifiedBundles).reduce((acc, [ bundleName, { js, scss } ]) => {
+      return {
+        js: [
+          ...acc.js,
+          ...(js.length && !acc.js.includes(bundleName)) ? [ bundleName ] : []
+        ],
+        css: [
+          ...acc.css,
+          ...(scss.length && !acc.css.includes(bundleName)) ? [ bundleName ] : []
+        ]
+      };
+    }, {
+      js: [],
+      css: []
+    });
+  },
+
+  getBundlesNames (bundles, es5 = false) {
+    return Object.entries(bundles).reduce((acc, [ ext, bundlesNames ]) => {
+      const nameExtension = ext === 'css'
+        ? '-bundle'
+        : '-module-bundle';
+
+      const es5Bundles = es5 && ext === 'js'
+        ? bundlesNames.map((name) => `${name}-nomodule-bundle.${ext}`)
+        : [];
+
+      return [
+        ...acc,
+        ...bundlesNames.map((name) => `${name}${nameExtension}.${ext}`),
+        ...es5Bundles
+      ];
+    }, []);
+  },
+
+  writeBundlesImportFiles ({
+    name,
+    buildDir,
+    mainBundleName,
+    verifiedBundles,
+    getImportFileOutput,
+    writeImportFile
+  }) {
+    if (!name.includes('src')) {
+      return [];
+    }
+
+    const bundlesOutputs = Object.entries(verifiedBundles)
+      .map(([ bundleName, paths ]) => {
+        return {
+          bundleName,
+          importFile: `${buildDir}/${bundleName}-import.js`,
+          js: getImportFileOutput(paths.js, {
+            invokeApps: true,
+            enumerateImports: true,
+            requireDefaultExport: true
+          }),
+          scss: getImportFileOutput(paths.scss, {
+            enumerateImports: true,
+            importSuffix: 'Stylesheet'
+          })
+        };
+      });
+
+    for (const output of bundlesOutputs) {
+      writeImportFile({
+        importFile: output.importFile,
+        indexJs: output.js,
+        indexSass: output.scss
+      });
+    }
+
+    return bundlesOutputs.reduce((acc, { bundleName, importFile }) => {
+      return {
+        ...acc,
+        [bundleName]: {
+          import: importFile,
+          dependOn: mainBundleName
+        }
+      };
+    }, {});
+  }
+};
+
+function getModulesWebpackConfigs (modulesMeta) {
+  const { extensions, bundles } = modulesMeta.reduce((acc, meta) => {
+    const { webpack, __meta } = meta;
+
+    const configs = formatConfigs(__meta.chain, webpack);
+
+    if (!configs.length) {
+      return acc;
+    }
+
+    const moduleBundles = configs.reduce((acc, conf) => {
+      return {
+        ...acc,
+        ...conf.bundles
+      };
+    }, {});
+
+    return {
+      extensions: {
+        ...acc.extensions,
+        ...configs.reduce((acc, config) => ({
+          ...acc,
+          ...config.extensions
+        }), {})
+      },
+      bundles: {
+        ...acc.bundles,
+        ...moduleBundles
+      }
+    };
+  }, {
+    extensions: {},
+    bundles: {}
+  });
+
+  return {
+    extensions,
+    foundBundles: flattenBundles(bundles)
+  };
+};
+
+async function verifyBundlesEntryPoints (bundles) {
+  const checkPathsPromises = bundles.map(async ({ bundleName, modulePath }) => {
+    const jsPath = `${modulePath}/ui/src/${bundleName}.js`;
+    const scssPath = `${modulePath}/ui/src/${bundleName}.scss`;
+
+    const jsFileExists = await fs.pathExists(jsPath);
+    const scssFileExists = await fs.pathExists(scssPath);
+
+    return {
+      bundleName,
+      ...jsFileExists && { jsPath: jsPath },
+      ...scssFileExists && { scssPath: scssPath }
+    };
+  });
+
+  const bundlesPaths = await Promise.all(checkPathsPromises);
+
+  const packedFilesByBundle = bundlesPaths.reduce((acc, {
+    bundleName, jsPath, scssPath
+  }) => {
+    if (!jsPath && !scssPath) {
+      return acc;
+    }
+
+    return {
+      ...acc,
+      [bundleName]: {
+        js: [
+          ...acc[bundleName] ? acc[bundleName].js : [],
+          ...jsPath ? [ jsPath ] : []
+        ],
+        scss: [
+          ...acc[bundleName] ? acc[bundleName].scss : [],
+          ...scssPath ? [ scssPath ] : []
+        ]
+      }
+    };
+  }, {});
+
+  return packedFilesByBundle;
+};
+
+function formatConfigs (chain, webpackConfigs) {
+  return Object.entries(webpackConfigs)
+    .map(([ name, config ], i) => {
+
+      if (!config) {
+        return null;
+      }
+
+      const { bundles = {}, extensions = {} } = config;
+
+      return {
+        extensions,
+        bundles: {
+          [name]: {
+            bundleNames: Object.keys(bundles),
+            modulePath: chain[i].dirname
+          }
+        }
+      };
+    }).filter((config) => config);
+}
+
+function flattenBundles (bundles) {
+  return Object.values(bundles)
+    .reduce((acc, { bundleNames, modulePath }) => {
+      return [
+        ...acc,
+        ...bundleNames.map((bundleName) => ({
+          bundleName,
+          modulePath
+        }))
+      ];
+    }, []);
+}

package/modules/@apostrophecms/asset/views/scripts.html

@@ -0,0 +1 @@
+{{ data.placeholder }}

package/modules/@apostrophecms/asset/views/stylesheets.html

@@ -0,0 +1 @@
+{{ data.placeholder }}

package/modules/@apostrophecms/doc/index.js

@@ -329,6 +329,10 @@ module.exports = {
           updatedAt: -1,
           aposLocale: 1
         }, {});
+        await self.db.createIndex({
+          relatedReverseIds: 1,
+          aposLocale: 1
+        }, {});
         await self.db.createIndex({ 'advisoryLock._id': 1 }, {});
         await self.createTextIndex();
         await self.db.createIndex({ parkedId: 1 }, {});
@@ -1093,6 +1097,66 @@ module.exports = {
           }
         });
       },
+
+      // Iterate through the document fields and call the provided handlers
+      // for each item of an array, object and relationship field type.
+      walkByMetaType(doc, handlers) {
+        const defaultHandlers = {
+          arrayItem: () => {},
+          object: () => {},
+          relationship: () => {}
+        };
+
+        handlers = {
+          ...defaultHandlers,
+          ...handlers
+        };
+
+        if (doc.metaType === 'doc') {
+          const manager = self.getManager(doc.type);
+          if (!manager) {
+            return;
+          }
+          forSchema(manager.schema, doc);
+        } else if (doc.metaType === 'widget') {
+          const manager = self.apos.area.getWidgetManager(doc.type);
+          if (!manager) {
+            return;
+          }
+          forSchema(manager.schema, doc);
+        }
+
+        function forSchema(schema, doc) {
+          for (const field of schema) {
+            if (field.type === 'area' && doc[field.name] && doc[field.name].items) {
+              for (const widget of doc[field.name].items) {
+                self.walkByMetaType(widget, {
+                  arrayItem: handlers.arrayItem,
+                  object: handlers.object,
+                  relationship: handlers.relationship
+                });
+              }
+            } else if (field.type === 'array') {
+              if (doc[field.name]) {
+                doc[field.name].forEach(item => {
+                  handlers.arrayItem(field, item);
+                  forSchema(field.schema, item);
+                });
+              }
+            } else if (field.type === 'object') {
+              const value = doc[field.name];
+              if (value) {
+                handlers.object(field, value);
+                forSchema(field.schema, value);
+              }
+            } else if (field.type === 'relationship') {
+              if (Array.isArray(doc[field.name])) {
+                handlers.relationship(field, doc);
+              }
+            }
+          }
+        }
+      },
       ...require('./lib/legacy-migrations')(self)
     };
   }

package/modules/@apostrophecms/doc-type/index.js

@@ -94,6 +94,29 @@ module.exports = {
   handlers(self) {
     return {
       beforeSave: {
+        async updateBacklinks(req, doc) {
+          const relatedDocsIds = self.getRelatedDocsIds(req, doc);
+
+          // Remove all references to the doc
+          await self.apos.doc.db.updateMany({
+            relatedReverseIds: { $in: [ doc.aposDocId ] },
+            aposLocale: { $in: [ doc.aposLocale, null ] }
+          }, {
+            $pull: { relatedReverseIds: doc.aposDocId }
+          });
+
+          if (!relatedDocsIds.length) {
+            return;
+          }
+
+          // Add doc reference to all related docs
+          await self.apos.doc.db.updateMany({
+            aposDocId: { $in: relatedDocsIds },
+            aposLocale: { $in: [ doc.aposLocale, null ] }
+          }, {
+            $push: { relatedReverseIds: doc.aposDocId }
+          });
+        },
         prepareForStorage(req, doc) {
           self.apos.schema.prepareForStorage(req, doc);
         },
@@ -253,6 +276,18 @@ module.exports = {
 
   methods(self) {
     return {
+      getRelatedDocsIds(req, doc) {
+        const relatedDocsIds = [];
+        const handlers = {
+          relationship: (field, doc) => {
+            relatedDocsIds.push(...doc[field.name].map(relatedDoc => self.apos.doc.toAposDocId(relatedDoc)));
+          }
+        };
+
+        self.apos.doc.walkByMetaType(doc, handlers);
+
+        return relatedDocsIds;
+      },
       sanitizeFieldList(choices) {
         if ((typeof choices) === 'string') {
           return choices.split(/\s*,\s*/);

package/modules/@apostrophecms/i18n/i18n/en.json

@@ -30,6 +30,8 @@
   "areYouSure": "Are You Sure?",
   "assetTypeBuildComplete": "👍 {{ label }} is complete!",
   "assetTypeBuilding": "🧑‍💻 Building the {{ label }}...",
+  "assetWebpackConfigWarning": "⚠️ In the module {{ module }}, your webpack config is incorrect. It must be an object and should contain only two properties extensions and bundles.",
+  "assetWebpackBundlesWarning": "⚠️ In the module {{ module }} your webpack config is incorrect. Each bundle can only have one property 'templates' that must be an array of strings.",
   "back": "Back",
   "backToHome": "Back to Home",
   "basics": "Basics",

package/modules/@apostrophecms/i18n/ui/apos/components/AposI18nLocalize.vue

@@ -717,6 +717,13 @@ export default {
                 ...getRelatedBySchema(value, field.schema)
               ];
             }
+          } else if (field.type === 'object') {
+            if (object[field.name]) {
+              related = [
+                ...related,
+                ...getRelatedBySchema(object[field.name], field.schema)
+              ];
+            }
           } else if (field.type === 'area') {
             for (const widget of (object[field.name]?.items || [])) {
               related = [

package/modules/@apostrophecms/login/index.js

@@ -682,6 +682,10 @@ module.exports = {
 
       // Awaitable wrapper for req.login. An implementation detail of the login route
       async passportLogin(req, user) {
+        const cookieName = `${self.apos.shortName}.${loggedInCookieName}`;
+        if (req.cookies[cookieName] !== 'true') {
+          req.res.cookie(cookieName, 'true');
+        }
         const passportLogin = (user) => {
           return require('util').promisify(function(user, callback) {
             return req.login(user, callback);

package/modules/@apostrophecms/schema/index.js

@@ -790,6 +790,7 @@ module.exports = {
     self.addFieldType({
       name: 'object',
       async convert(req, field, data, destination) {
+        data = data[field.name];
         const schema = field.schema;
         const errors = [];
         const result = {
@@ -808,6 +809,8 @@ module.exports = {
             });
           }
         }
+        result.metaType = 'objectItem';
+        result.scopedObjectName = field.scopedObjectName;
         destination[field.name] = result;
         if (errors.length) {
           throw errors;
@@ -821,6 +824,11 @@ module.exports = {
         };
         self.register(metaType, type, field.schema);
       },
+      validate: function (field, options, warn, fail) {
+        for (const subField of field.schema || field.fields.add) {
+          self.validateField(subField, options);
+        }
+      },
       isEqual(req, field, one, two) {
         if (one && (!two)) {
           return false;
@@ -831,6 +839,15 @@ module.exports = {
         if (!(one || two)) {
           return true;
         }
+        if (one[field.name] && (!two[field.name])) {
+          return false;
+        }
+        if (two[field.name] && (!one[field.name])) {
+          return false;
+        }
+        if (!(one[field.name] || two[field.name])) {
+          return true;
+        }
         return self.isEqual(req, field.schema, one[field.name], two[field.name]);
       },
       def: {}
@@ -1952,59 +1969,31 @@ module.exports = {
       // Currently `req` does not impact this, but that may change.
 
       prepareForStorage(req, doc) {
-        if (doc.metaType === 'doc') {
-          const manager = self.apos.doc.getManager(doc.type);
-          if (!manager) {
-            return;
-          }
-          forSchema(manager.schema, doc);
-        } else if (doc.metaType === 'widget') {
-          const manager = self.apos.area.getWidgetManager(doc.type);
-          if (!manager) {
-            return;
-          }
-          forSchema(manager.schema, doc);
-        }
-        function forSchema(schema, doc) {
-          for (const field of schema) {
-            if (field.type === 'area') {
-              if (doc[field.name] && doc[field.name].items) {
-                for (const widget of doc[field.name].items) {
-                  self.prepareForStorage(req, widget);
-                }
-              }
-            } else if (field.type === 'array') {
-              if (doc[field.name]) {
-                doc[field.name].forEach(item => {
-                  item._id = item._id || self.apos.util.generateId();
-                  item.metaType = 'arrayItem';
-                  item.scopedArrayName = field.scopedArrayName;
-                  forSchema(field.schema, item);
-                });
-              }
-            } else if (field.type === 'object') {
-              const value = doc[field.name];
-              if (value) {
-                value.metaType = 'object';
-                value.scopedObjectName = field.scopedObjectName;
-                forSchema(field.schema, value);
-              }
-            } else if (field.type === 'relationship') {
-              if (Array.isArray(doc[field.name])) {
-                doc[field.idsStorage] = doc[field.name].map(relatedDoc => self.apos.doc.toAposDocId(relatedDoc));
-                if (field.fieldsStorage) {
-                  const fieldsById = doc[field.fieldsStorage] || {};
-                  for (const relatedDoc of doc[field.name]) {
-                    if (relatedDoc._fields) {
-                      fieldsById[self.apos.doc.toAposDocId(relatedDoc)] = relatedDoc._fields;
-                    }
-                  }
-                  doc[field.fieldsStorage] = fieldsById;
+        const handlers = {
+          arrayItem: (field, object) => {
+            object._id = object._id || self.apos.util.generateId();
+            object.metaType = 'arrayItem';
+            object.scopedArrayName = field.scopedArrayName;
+          },
+          object: (field, object) => {
+            object.metaType = 'object';
+            object.scopedObjectName = field.scopedObjectName;
+          },
+          relationship: (field, doc) => {
+            doc[field.idsStorage] = doc[field.name].map(relatedDoc => self.apos.doc.toAposDocId(relatedDoc));
+            if (field.fieldsStorage) {
+              const fieldsById = doc[field.fieldsStorage] || {};
+              for (const relatedDoc of doc[field.name]) {
+                if (relatedDoc._fields) {
+                  fieldsById[self.apos.doc.toAposDocId(relatedDoc)] = relatedDoc._fields;
                 }
               }
+              doc[field.fieldsStorage] = fieldsById;
             }
           }
-        }
+        };
+
+        self.apos.doc.walkByMetaType(doc, handlers);
       },
 
       // Add a new field type. The `type` object may contain the following properties:
@@ -2540,6 +2529,8 @@ module.exports = {
               item._id = self.apos.util.generateId();
               self.regenerateIds(req, field.schema, item);
             }
+          } else if (field.type === 'object') {
+            this.regenerateIds(req, field.schema, doc[field.name] || {});
           } else if (field.type === 'area') {
             if (doc[field.name]) {
               doc[field.name]._id = self.apos.util.generateId();