Merge branch 'main' into pro-8356-match-slug-across-locales

* main:
  PRO-8708: bring back passing of the actual area options in the form developers expect to see them to custom insert menu item components (#5162)
  adds object of useful error when widget fails to render (#5141)
  add addMissingSchemaFields task (#5101)
  Pro 8360 box field (#5142)
  Pro 8671 fix localize modal (#5156)
  longPolling: false option (#5154)
  PRO-5472: file widget (#5126)

Author: haroun

.github/workflows/main.yml

@@ -18,21 +18,21 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [20, 22]
+        node-version: [20, 22, 24]
         mongodb-version: [6.0, 7.0, 8.0]
 
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
       - name: Git checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: ${{ matrix.node-version }}
 
       - name: Start MongoDB
-        uses: supercharge/mongodb-github-action@1.11.0
+        uses: supercharge/mongodb-github-action@1.12.0
         with:
           mongodb-version: ${{ matrix.mongodb-version }}
 

CHANGELOG.md

@@ -4,18 +4,25 @@
 
 ### Adds
 
+* Add `@apostrophecms/migration:add-missing-schema-fields` task. This task does not run database migrations.
 * Translation strings added for the layout- and layout-column-widgets.
 * Adds `@apostrophecms/doc:get-apos-doc-id` and `@apostrophecms/doc:set-apos-doc-id` tasks.
+* New `box` schema field type
 * When switching locale from the doc editor, ask if the user wants to localize the current document in the target locale or want to start a blank document.
+* Introduced a new `longPolling: false` option for the `@apostrophecms/notification` module. This eliminates long-pending requests when logged in, but also slows down the delivery of notifications. The behavior can be tuned further via the `pollingInterval` option, which defaults to `5000` milliseconds.
 
 ### Changes
 
+* `@apostrophecms/migration:requirements` handler now runs the migration requirements like `insertIfMissing`, `implementParkAllInDefaultLocale`, `replicate` and `implementParkAllInOtherLocales`.
 * Bump nodemailer to v7.x.
+* Improves client error log when unable to render a widget.
+* Rich text `styles` are once again available to insert menu items, such as our optional `@apostrophecms/ai-helper` module.
 
 ### Fixes
 
 * Specify the content type when calling back to Astro with JSON to render an area. This is required starting in Astro 4.9.0 and up, otherwise the request is blocked by CSRF protection.
 * Fixes `AposBreadcrumbSwitch` tooltip prop that is supposed to be an object, not a string. Object returned from the shared method `getOperationTooltip`.
+* Uses `modalData.locale` in `AposI18nLocalize` component. Fixes watcher on `relatedDocTypes` not being properly triggered (uses data and methods for more control instead).
 
 ## 4.23.0 (2025-10-30)
 

defaults.js

@@ -46,8 +46,10 @@ module.exports = {
     '@apostrophecms/rich-text-widget': {},
     '@apostrophecms/html-widget': {},
     '@apostrophecms/color-field': {},
+    '@apostrophecms/box-field': {},
     '@apostrophecms/oembed-field': {},
     '@apostrophecms/video-widget': {},
+    '@apostrophecms/file-widget': {},
     '@apostrophecms/ui': {},
     '@apostrophecms/user': {},
     '@apostrophecms/settings': {},

index.js

@@ -323,21 +323,7 @@ async function apostrophe(options, telemetry, rootSpan) {
     await self.emit('modulesRegistered'); // formerly modulesReady
     self.apos.schema.validateAllSchemas();
     self.apos.schema.registerAllSchemas();
-    await self.apos.lock.withLock('@apostrophecms/migration:migrate', async () => {
-      await self.apos.migration.migrate(self.argv);
-      // Inserts the global doc in the default locale if it does not exist;
-      // same for other singleton piece types registered by other modules
-      for (const apostropheModule of Object.values(self.modules)) {
-        if (self.instanceOf(apostropheModule, '@apostrophecms/piece-type') && apostropheModule.options.singletonAuto) {
-          await apostropheModule.insertIfMissing();
-        }
-      }
-      await self.apos.page.implementParkAllInDefaultLocale();
-      await self.apos.doc.replicate(); // emits beforeReplicate and afterReplicate events
-      // Replicate will have created the parked pages across locales if needed,
-      // but we may still need to reset parked properties
-      await self.apos.page.implementParkAllInOtherLocales();
-    });
+    await self.apos.migration.migrate(self.argv);
     await self.emit('ready'); // formerly afterInit
 
     if (self.taskRan) {

modules/@apostrophecms/box-field/index.js

@@ -0,0 +1,157 @@
+module.exports = {
+  options: {
+    name: 'box',
+    alias: 'boxField'
+  },
+  init(self) {
+    self.name = self.options.name;
+    self.addFieldType();
+    self.enableBrowserData();
+  },
+  methods(self) {
+    return {
+      addFieldType() {
+        self.apos.schema.addFieldType({
+          name: 'box',
+          convert(req, field, data, destination) {
+            const defProps = [ 'top', 'right', 'bottom', 'left' ];
+            const temp = {};
+            const min = self.apos.launder.integer(field.min);
+            let max = null;
+
+            if ('max' in field) {
+              max = self.apos.launder.integer(field.max);
+            }
+
+            // All values to numbers or null
+            defProps.forEach(side => {
+              const int = parseInt(data[field.name][side]);
+              if (int || int === 0) {
+                temp[side] = int;
+              } else {
+                temp[side] = null;
+              }
+            });
+
+            // One non-null value if required
+            if (field.required) {
+              const unique = [ ...new Set(Object.values(temp)) ];
+              if (unique.length === 1 && unique[0] === null) {
+                throw self.apos.error('required');
+              }
+            }
+
+            // Minimum values in range
+            for (const key of defProps) {
+              if (temp[key] && temp < min) {
+                throw self.apos.error(`${key} is below the min ${field.min}, is ${temp[key]}`);
+              }
+            }
+
+            // Maximum values in range
+            if (max) {
+              for (const key of defProps) {
+                if (temp[key] && temp[key] > field.max) {
+                  throw self.apos.error(`${key} is greater than the max ${field.max}, is ${temp[key]}`);
+                }
+              }
+            }
+
+            // Copy values to destination
+            destination[field.name] = temp;
+          },
+          validate(field, options, warn, fail) {
+            const defProps = [ 'top', 'right', 'bottom', 'left' ];
+            let defMin = 0;
+
+            if (field.max && typeof field.max !== 'number') {
+              fail('Property "max" must be a number');
+            }
+
+            if (field.step && typeof field.step !== 'number') {
+              fail('Property "step" must be a number');
+            }
+
+            if (field.def) {
+              const fieldDefProps = Object.keys(field.def);
+              if (
+                !(fieldDefProps.length === defProps.length &&
+                fieldDefProps.every(k => defProps.includes(k)))
+              ) {
+                fail('Def must be an object with only "top", "right", "bottom", and "left" keys');
+              }
+
+              for (const key in field.def) {
+                if (!Number.isFinite(field.def[key])) {
+                  fail(`Default property "${key}" must be a number`);
+                }
+              }
+            }
+
+            if (field.min) {
+              if (typeof field.min !== 'number') {
+                fail('Property "min" must be a number');
+              }
+            } else {
+              if (field.def) {
+                // if def has a negative value, it needs to be the min
+                const fieldDefMin = Math.min(...Object.values(field.def));
+                if (defMin > fieldDefMin) {
+                  defMin = fieldDefMin;
+                }
+              }
+              field.min = defMin;
+            }
+
+          },
+          def: {
+            top: null,
+            right: null,
+            bottom: null,
+            left: null
+          }
+        });
+      },
+      getBrowserData(req) {
+        return {
+          name: self.name,
+          action: self.action
+        };
+      }
+    };
+  },
+  helpers() {
+    return {
+      toCss(value, property, unit = 'px') {
+        const {
+          top, right, bottom, left
+        } = value;
+        const vals = [ top, right, bottom, left ];
+
+        if (vals.every(v => v == null)) {
+          return '';
+        };
+
+        if (vals.every(v => v === top && v != null)) {
+          return `${property}: ${top}${unit};`;
+        }
+
+        const sides = {
+          top,
+          right,
+          bottom,
+          left
+        };
+        const parts = [];
+
+        for (const [ side, val ] of Object.entries(sides)) {
+          if (val != null) {
+            parts.push(`${property}-${side}: ${val}${unit};`);
+          }
+        }
+
+        return parts.join(' ');
+      }
+    };
+  }
+};