apostrophe 4.6.1 → 4.7.0

package/test/schemas.js

@@ -326,6 +326,63 @@ describe('Schemas', function() {
               }
             };
           }
+        },
+        topic: {
+          extend: '@apostrophecms/piece-type',
+          options: {
+            alias: 'topic'
+          },
+          fields(self) {
+            return {
+              add: {
+                title: {
+                  label: 'Title',
+                  type: 'string',
+                  required: true
+                },
+                area: {
+                  label: 'Area',
+                  type: 'area',
+                  options: {
+                    widgets: {
+                      '@apostrophecms/image': {}
+                    }
+                  }
+                },
+                _rel: {
+                  label: 'Rel',
+                  type: 'relationship',
+                  withType: 'article'
+                },
+                array: {
+                  label: 'Array',
+                  type: 'array',
+                  fields: {
+                    add: {
+                      _arrayRel: {
+                        label: 'Array Rel',
+                        type: 'relationship',
+                        withType: 'article'
+                      }
+                    }
+                  }
+                },
+                object: {
+                  label: 'Object',
+                  type: 'object',
+                  fields: {
+                    add: {
+                      _objectRel: {
+                        label: 'Object Rel',
+                        type: 'relationship',
+                        withType: 'article'
+                      }
+                    }
+                  }
+                }
+              }
+            };
+          }
         }
       }
     });
@@ -2401,6 +2458,276 @@ describe('Schemas', function() {
     assert.deepEqual(actual, expected);
   });
 
+  it('should allow to simulate a populate of relationships on database data', async function() {
+    const req = apos.task.getReq();
+    const doc = {
+      _id: 'gvoyi3l0ncsj2yq36743zeum:en:draft',
+      title: 'topic',
+      array: [
+        {
+          _id: 'hy56r2znrs427m47e15yesfb',
+          metaType: 'arrayItem',
+          scopedArrayName: 'doc.topic.array',
+          arrayRelIds: [ 'nkr88dg4lds8noal9l4vrcgv' ],
+          arrayRelFields: { nkr88dg4lds8noal9l4vrcgv: {} }
+        }
+      ],
+      object: {
+        _id: 'tfpq5v6lwlwomuampavh6zi8',
+        metaType: 'object',
+        scopedObjectName: 'doc.topic.object',
+        objectRelIds: [ 'nkr88dg4lds8noal9l4vrcgv', 'az82H8dg4lds8noal9l4vazd' ],
+        objectRelFields: {
+          nkr88dg4lds8noal9l4vrcgv: {},
+          az82H8dg4lds8noal9l4vazd: {}
+        }
+      },
+      slug: 'topic',
+      visibility: 'public',
+      scheduledPublish: null,
+      scheduledUnpublish: null,
+      aposIsTemplate: false,
+      aposPreviewImage: {
+        _id: 'gx4ankjn1s0i2g16qs16is0q',
+        items: [],
+        metaType: 'area'
+      },
+      userPermissions: [],
+      groupPermissions: [],
+      archived: false,
+      type: 'topic',
+      aposLocale: 'en:draft',
+      aposMode: 'draft',
+      aposDocId: 'gvoyi3l0ncsj2yq36743zeum',
+      metaType: 'doc',
+      createdAt: '2024-08-07T07:11:34.234Z',
+      updatedAt: '2024-08-07T07:24:17.889Z',
+      cacheInvalidatedAt: '2024-08-07T07:24:17.889Z',
+      updatedBy: {
+        _id: 'vndh00in6p565asvbivvzjos',
+        title: 'admin',
+        username: 'admin'
+      },
+      titleSortified: 'topic',
+      highSearchText: 'topic topic topic topic public',
+      highSearchWords: [ 'topic', 'public' ],
+      lowSearchText: 'topic topic topic topic public',
+      searchSummary: '',
+      aposPermissions: [],
+      modified: false,
+      lastPublishedAt: '2024-08-07T07:24:17.956Z',
+      relIds: [ 'reyvb1txf54noynckm1xy34a' ],
+      relFields: { reyvb1txf54noynckm1xy34a: {} },
+      area: {
+        _id: 'hfwxext12500kxy74coc3nf1',
+        items: [
+          {
+            _id: 'x38pvsmyqie83vzy57akpwb2',
+            metaType: 'widget',
+            type: '@apostrophecms/image',
+            aposPlaceholder: false,
+            imageIds: [ 'u2gcjvq9wvds1hkd8xibn9h1' ],
+            imageFields: {
+              u2gcjvq9wvds1hkd8xibn9h1: {
+                top: null,
+                left: null,
+                width: null,
+                height: null,
+                x: null,
+                y: null
+              }
+            }
+          }
+        ],
+        metaType: 'area'
+      }
+    };
+
+    apos.schema.simulateRelationshipsFromStorage(req, doc);
+
+    const actual = {
+      rel: doc._rel,
+      area: doc.area.items[0]._image,
+      array: doc.array[0]._arrayRel,
+      object: doc.object._objectRel
+    };
+
+    const expected = {
+      rel: [
+        {
+          _id: 'reyvb1txf54noynckm1xy34a:en:draft',
+          _fields: {}
+        }
+      ],
+      area: [
+        {
+          _id: 'u2gcjvq9wvds1hkd8xibn9h1:en:draft',
+          _fields: {
+            top: null,
+            left: null,
+            width: null,
+            height: null,
+            x: null,
+            y: null
+          }
+        }
+      ],
+      array: [
+        {
+          _id: 'nkr88dg4lds8noal9l4vrcgv:en:draft',
+          _fields: {}
+        }
+      ],
+      object: [
+        {
+          _id: 'nkr88dg4lds8noal9l4vrcgv:en:draft',
+          _fields: {}
+        },
+        {
+          _id: 'az82H8dg4lds8noal9l4vazd:en:draft',
+          _fields: {}
+        }
+      ]
+    };
+
+    assert.deepEqual(actual, expected);
+  });
+
+  it('should allow to convert a document without fetching relationships', async function() {
+    const req = apos.task.getReq();
+    const doc = {
+      _id: 'gvoyi3l0ncsj2yq36743zeum:en:draft',
+      title: 'topic',
+      array: [
+        {
+          _id: 'hy56r2znrs427m47e15yesfb',
+          metaType: 'arrayItem',
+          scopedArrayName: 'doc.topic.array',
+          arrayRelIds: [ 'nkr88dg4lds8noal9l4vrcgv' ],
+          arrayRelFields: { nkr88dg4lds8noal9l4vrcgv: {} }
+        }
+      ],
+      object: {
+        _id: 'tfpq5v6lwlwomuampavh6zi8',
+        metaType: 'object',
+        scopedObjectName: 'doc.topic.object',
+        objectRelIds: [ 'nkr88dg4lds8noal9l4vrcgv', 'az82H8dg4lds8noal9l4vazd' ],
+        objectRelFields: {
+          nkr88dg4lds8noal9l4vrcgv: {},
+          az82H8dg4lds8noal9l4vazd: {}
+        }
+      },
+      slug: 'topic',
+      visibility: 'public',
+      scheduledPublish: null,
+      scheduledUnpublish: null,
+      aposIsTemplate: false,
+      aposPreviewImage: {
+        _id: 'gx4ankjn1s0i2g16qs16is0q',
+        items: [],
+        metaType: 'area'
+      },
+      userPermissions: [],
+      groupPermissions: [],
+      archived: false,
+      type: 'topic',
+      aposLocale: 'en:draft',
+      aposMode: 'draft',
+      aposDocId: 'gvoyi3l0ncsj2yq36743zeum',
+      metaType: 'doc',
+      createdAt: '2024-08-07T07:11:34.234Z',
+      updatedAt: '2024-08-07T07:24:17.889Z',
+      cacheInvalidatedAt: '2024-08-07T07:24:17.889Z',
+      updatedBy: {
+        _id: 'vndh00in6p565asvbivvzjos',
+        title: 'admin',
+        username: 'admin'
+      },
+      titleSortified: 'topic',
+      highSearchText: 'topic topic topic topic public',
+      highSearchWords: [ 'topic', 'public' ],
+      lowSearchText: 'topic topic topic topic public',
+      searchSummary: '',
+      aposPermissions: [],
+      modified: false,
+      lastPublishedAt: '2024-08-07T07:24:17.956Z',
+      relIds: [ 'reyvb1txf54noynckm1xy34a' ],
+      relFields: { reyvb1txf54noynckm1xy34a: {} },
+      area: {
+        _id: 'hfwxext12500kxy74coc3nf1',
+        items: [
+          {
+            _id: 'x38pvsmyqie83vzy57akpwb2',
+            metaType: 'widget',
+            type: '@apostrophecms/image',
+            aposPlaceholder: false,
+            imageIds: [ 'u2gcjvq9wvds1hkd8xibn9h1' ],
+            imageFields: {
+              u2gcjvq9wvds1hkd8xibn9h1: {
+                top: null,
+                left: null,
+                width: null,
+                height: null,
+                x: null,
+                y: null
+              }
+            }
+          }
+        ],
+        metaType: 'area'
+      }
+    };
+
+    apos.schema.simulateRelationshipsFromStorage(req, doc);
+    const docToInsert = doc;
+    const schema = apos.doc.getManager('topic').schema;
+    await apos.schema.convert(req, schema, doc, docToInsert, {
+      fetchRelationships: false
+    });
+
+    const actual = {
+      rel: docToInsert._rel,
+      area: docToInsert.area.items[0]._image,
+      array: docToInsert.array[0]._arrayRel,
+      object: docToInsert.object._objectRel
+    };
+    const expected = {
+      rel: [ {
+        _id: 'reyvb1txf54noynckm1xy34a:en:draft',
+        _fields: {}
+      } ],
+      area: [
+        {
+          _id: 'u2gcjvq9wvds1hkd8xibn9h1:en:draft',
+          _fields: {
+            top: null,
+            left: null,
+            width: null,
+            height: null,
+            x: null,
+            y: null
+          }
+        }
+      ],
+      array: [ {
+        _id: 'nkr88dg4lds8noal9l4vrcgv:en:draft',
+        _fields: {}
+      } ],
+      object: [
+        {
+          _id: 'nkr88dg4lds8noal9l4vrcgv:en:draft',
+          _fields: {}
+        },
+        {
+          _id: 'az82H8dg4lds8noal9l4vazd:en:draft',
+          _fields: {}
+        }
+      ]
+    };
+
+    assert.deepEqual(actual, expected);
+  });
+
   describe('field.readOnly with default value', function() {
     const givenSchema = [
       {

package/test/utils.js

@@ -1,7 +1,7 @@
 const t = require('../test-lib/test.js');
 const assert = require('assert');
 const _ = require('lodash');
-const { debounce, throttle } = require('../modules/@apostrophecms/ui/ui/apos/utils/index');
+const { debounceAsync, throttle } = require('../modules/@apostrophecms/ui/ui/apos/utils/index');
 
 describe('Utils', function() {
 
@@ -376,10 +376,10 @@ describe('Utils', function() {
       const calledAsyncSlow = [];
       let asyncErrCatched = false;
 
-      const debouncedNormal = debounce(normalFn, 50);
-      const debouncedAsync = debounce(asyncFn, 50);
-      const debouncedAsyncSlow = debounce(asyncSlowFn, 50);
-      const debouncedAsyncErr = debounce(AsyncErrFn, 50);
+      const debouncedNormal = debounceAsync(normalFn, 50);
+      const debouncedAsync = debounceAsync(asyncFn, 50);
+      const debouncedAsyncSlow = debounceAsync(asyncSlowFn, 50);
+      const debouncedAsyncErr = debounceAsync(AsyncErrFn, 50);
 
       debouncedNormal(1);
       debouncedNormal(2);
@@ -441,6 +441,267 @@ describe('Utils', function() {
 
     });
 
+    it('should cancel debounced calls (sync)', async function () {
+      let calledSync = [];
+
+      function syncFn(num) {
+        calledSync.push(num);
+        return 'test';
+      };
+
+      const debouncedSync = debounceAsync(syncFn, 50);
+
+      debouncedSync(1);
+      await wait(200);
+      debouncedSync(2);
+      debouncedSync(3);
+      debouncedSync.cancel();
+      assert.deepEqual(calledSync, [ 1 ], 'should cancel all calls after the first call');
+      calledSync = [];
+
+      debouncedSync(1);
+      debouncedSync(2);
+      debouncedSync(3);
+      debouncedSync.cancel();
+      await wait(200);
+      assert.deepEqual(calledSync, [], 'should cancel all calls when canceled after the 3rd call');
+      calledSync = [];
+
+      debouncedSync(1);
+      debouncedSync(2);
+      debouncedSync.cancel();
+      debouncedSync(3);
+      await wait(100);
+      assert.deepEqual(calledSync, [], 'should cancel all calls when canceled after the 2nd call');
+      calledSync = [];
+
+      debouncedSync(1);
+      debouncedSync(2);
+      debouncedSync.cancel();
+      await wait(100);
+      debouncedSync(3);
+      await wait(100);
+      assert.deepEqual(
+        calledSync,
+        [],
+        'should cancel all calls when canceled and called again after some time'
+      );
+    });
+
+    it('should cancel debounced calls (async)', async function () {
+      let calledAsync = [];
+
+      async function asyncFn(num) {
+        await wait(50);
+        calledAsync.push(num);
+        // Keep all console.debug around to easy debug - ensure
+        // all promises are awaited before the test ends.
+        console.debug('calledAsync', num);
+        return 'async';
+      }
+
+      const debouncedAsync = debounceAsync(asyncFn, 50);
+
+      debouncedAsync(1);
+      await wait(100);
+      debouncedAsync(2);
+      debouncedAsync(3);
+      debouncedAsync.cancel();
+      await wait(200);
+      assert.deepEqual(calledAsync, [ 1 ], 'should cancel all calls after the first call');
+      calledAsync = [];
+
+      debouncedAsync(1);
+      debouncedAsync(2);
+      debouncedAsync(3);
+      debouncedAsync.cancel();
+      await wait(200);
+      assert.deepEqual(calledAsync, [], 'should cancel all calls when canceled after the 3rd call');
+      calledAsync = [];
+
+      debouncedAsync(1);
+      debouncedAsync(2);
+      debouncedAsync.cancel();
+      debouncedAsync(3);
+      await wait(200);
+      assert.deepEqual(calledAsync, [], 'should cancel all calls when canceled after the 2nd call');
+      calledAsync = [];
+
+      debouncedAsync(1);
+      debouncedAsync(2);
+      debouncedAsync.cancel();
+      await wait(200);
+      debouncedAsync(3);
+      await wait(100);
+      assert.deepEqual(
+        calledAsync,
+        [],
+        'should cancel all calls when canceled and called again after some time'
+      );
+    });
+
+    it('should reject ongoing promises after debounce cancel', async function () {
+      const calledAsync = [];
+      async function asyncFn(num, time = 50) {
+        await wait(time);
+        calledAsync.push(num);
+        console.debug('unstoppable async call', num);
+        return 'async';
+      }
+
+      const debouncedAsync = debounceAsync(asyncFn, 50);
+      const promise = debouncedAsync(1, 300);
+      await wait(100);
+      debouncedAsync.cancel();
+
+      await assert.rejects(promise, {
+        name: 'debounce.canceled',
+        message: 'debounce:canceled'
+      });
+
+      assert.deepEqual(calledAsync, [ 1 ], 'the original promise should always resolve');
+    });
+
+    it('should NOT INVOKE onSuccess callback and not reject when canceled', async function () {
+      const calledAsync = [];
+      async function asyncStatelessFn(num, time = 50) {
+        await wait(time);
+        console.debug('asyncStatelessFn:', num);
+        return `async ${num}`;
+      }
+      async function asyncSideEffectFn(result) {
+        await wait(50);
+        console.debug('asyncSideEffectFn:', result);
+        calledAsync.push(result + ' side effect');
+      }
+
+      const debouncedAsync = debounceAsync(asyncStatelessFn, 50, {
+        onSuccess: asyncSideEffectFn
+      });
+      const promise = debouncedAsync(1, 300);
+      await wait(100);
+      debouncedAsync.cancel();
+
+      const result = await promise;
+
+      assert.strictEqual(result, null);
+      assert.deepEqual(
+        calledAsync,
+        [],
+        'the side effect should not be called'
+      );
+    });
+
+    it('should invoke onSuccess callback when not canceled', async function () {
+      const calledAsync = [];
+      async function asyncStatelessFn(num, time = 50) {
+        await wait(time);
+        console.debug('asyncStatelessFn:', num);
+        return `async ${num}`;
+      }
+      async function asyncSideEffectFn(result) {
+        await wait(50);
+        console.debug('asyncSideEffectFn:', result);
+        calledAsync.push(result + ' side effect');
+      }
+
+      const debouncedAsync = debounceAsync(asyncStatelessFn, 50, {
+        onSuccess: asyncSideEffectFn
+      });
+      const result = await debouncedAsync(1);
+      await wait(300);
+
+      assert.deepEqual(
+        calledAsync,
+        [ 'async 1 side effect' ],
+        'the side effect should be called'
+      );
+      assert.strictEqual(result, null);
+    });
+
+    it('should skip the next delay when invoked via skipDelay', async function () {
+      const invoked = [];
+      const calledAsync = [];
+      async function asyncStatelessFn(num, time = 50) {
+        invoked.push(num);
+        await wait(time);
+        console.debug('asyncStatelessFn:', num);
+        return `async ${num}`;
+      }
+      async function asyncSideEffectFn(result) {
+        await wait(50);
+        console.debug('asyncSideEffectFn:', result);
+        calledAsync.push(result + ' side effect');
+      }
+
+      const debouncedAsync = debounceAsync(asyncStatelessFn, 300, {
+        onSuccess: asyncSideEffectFn
+      });
+      debouncedAsync.skipDelay(1, 20);
+      await wait(100);
+      debouncedAsync(2);
+
+      assert.deepEqual(
+        calledAsync,
+        [ 'async 1 side effect' ],
+        'the side effect should be called'
+      );
+      assert.deepEqual(
+        invoked,
+        [ 1 ],
+        'bad invokation of the original function'
+      );
+
+      // Wait for the entire delay time to pass.
+      await wait(500);
+      assert.deepEqual(
+        calledAsync,
+        [ 'async 1 side effect', 'async 2 side effect' ],
+        'the side effect should be called'
+      );
+      assert.deepEqual(
+        invoked,
+        [ 1, 2 ],
+        'bad invokation of the original function after the end of the delay'
+      );
+    });
+
+    it('should bounce skipDelay as well', async function () {
+      const invoked = [];
+      const calledAsync = [];
+
+      async function asyncStatelessFn(num, time = 50) {
+        invoked.push(num);
+        await wait(time);
+        console.debug('asyncStatelessFn:', num);
+        return `async ${num}`;
+      }
+      async function asyncSideEffectFn(result) {
+        await wait(50);
+        console.debug('asyncSideEffectFn:', result);
+        calledAsync.push(result + ' side effect');
+      }
+
+      const debouncedAsync = debounceAsync(asyncStatelessFn, 100, {
+        onSuccess: asyncSideEffectFn
+      });
+      debouncedAsync(1);
+      debouncedAsync.skipDelay(2);
+      debouncedAsync(3);
+      await wait(500);
+
+      assert.deepEqual(
+        calledAsync,
+        [ 'async 1 side effect', 'async 3 side effect' ],
+        'the side effect should be called'
+      );
+      assert.deepEqual(
+        invoked,
+        [ 1, 3 ],
+        'bad invokation of the original function'
+      );
+    });
+
     it('can throttle functions', async function () {
       const calledNormal = [];
       const calledAsync = [];