@strapi/strapi 4.10.0-beta.1 → 4.10.1-experimental.0

package/lib/core/registries/__tests__/custom-fields.test.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const customFieldsRegistry = require('../custom-fields');
+
+const strapi = {
+  plugins: { plugintest: 'foo' },
+  plugin: jest.fn((plugin) => strapi.plugins[plugin]),
+};
+
+describe('Custom fields registry', () => {
+  describe('add', () => {
+    it('adds a custom field registered in a plugin', () => {
+      const mockCF = {
+        name: 'test',
+        plugin: 'plugintest',
+        type: 'text',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+      customFields.add(mockCF);
+
+      const expected = {
+        'plugin::plugintest.test': mockCF,
+      };
+      expect(customFields.getAll()).toEqual(expected);
+    });
+
+    it('adds a custom field not registered in a plugin', () => {
+      const mockCF = {
+        name: 'test',
+        type: 'text',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+      customFields.add(mockCF);
+
+      const expected = {
+        'global::test': mockCF,
+      };
+      expect(customFields.getAll()).toEqual(expected);
+    });
+
+    it('requires a name key on the custom field', () => {
+      const mockCF = {
+        type: 'test',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+
+      expect(() => customFields.add(mockCF)).toThrowError(
+        `Custom fields require a 'name' and 'type' key`
+      );
+    });
+
+    it('requires a type key on the custom field', () => {
+      const mockCF = {
+        name: 'test',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+
+      expect(() => customFields.add(mockCF)).toThrowError(
+        `Custom fields require a 'name' and 'type' key`
+      );
+    });
+
+    it('validates the name can be used as an object key', () => {
+      const mockCF = {
+        name: 'test.boom',
+        type: 'text',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+
+      expect(() => customFields.add(mockCF)).toThrowError(
+        `Custom field name: 'test.boom' is not a valid object key`
+      );
+    });
+
+    it('validates the type is a Strapi type', () => {
+      const mockCF = {
+        name: 'test',
+        type: 'geojson',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+
+      expect(() => customFields.add(mockCF)).toThrowError(
+        `Custom field type: 'geojson' is not a valid Strapi type`
+      );
+    });
+
+    it('validates inputSize', () => {
+      const mockCF = {
+        name: 'test',
+        type: 'text',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+
+      expect(() => customFields.add({ ...mockCF, inputSize: 'small' })).toThrowError(
+        `inputSize should be an object with 'default' and 'isResizable' keys`
+      );
+      expect(() => customFields.add({ ...mockCF, inputSize: ['array'] })).toThrowError(
+        `inputSize should be an object with 'default' and 'isResizable' keys`
+      );
+      expect(() =>
+        customFields.add({ ...mockCF, inputSize: { default: 99, isResizable: true } })
+      ).toThrowError('Custom fields require a valid default input size');
+      expect(() =>
+        customFields.add({ ...mockCF, inputSize: { default: 12, isResizable: 'true' } })
+      ).toThrowError('Custom fields should specify if their input is resizable');
+    });
+
+    it('confirms the custom field does not already exist', () => {
+      const mockCF = {
+        name: 'test',
+        plugin: 'plugintest',
+        type: 'text',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+
+      customFields.add(mockCF);
+      expect(() => customFields.add(mockCF)).toThrowError(
+        `Custom field: 'plugin::plugintest.test' has already been registered`
+      );
+    });
+  });
+  describe('get', () => {
+    it('gets a registered custom field', () => {
+      const mockCF = {
+        name: 'test',
+        plugin: 'plugintest',
+        type: 'text',
+      };
+
+      const customFields = customFieldsRegistry(strapi);
+      customFields.add(mockCF);
+
+      expect(customFields.get('plugin::plugintest.test')).toEqual(mockCF);
+    });
+
+    it('throws when a custom field is not registered', () => {
+      const customFields = customFieldsRegistry(strapi);
+
+      expect(() => customFields.get('plugin::plugintest.test')).toThrowError(
+        `Could not find Custom Field: plugin::plugintest.test`
+      );
+    });
+  });
+});

package/lib/core/registries/custom-fields.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { has } = require('lodash/fp');
+const { has, isPlainObject } = require('lodash/fp');
 
 const ALLOWED_TYPES = [
   'biginteger',
@@ -44,7 +44,7 @@ const customFieldsRegistry = (strapi) => {
           throw new Error(`Custom fields require a 'name' and 'type' key`);
         }
 
-        const { name, plugin, type } = cf;
+        const { name, plugin, type, inputSize } = cf;
         if (!ALLOWED_TYPES.includes(type)) {
           throw new Error(
             `Custom field type: '${type}' is not a valid Strapi type or it can't be used with a Custom Field`
@@ -56,6 +56,23 @@ const customFieldsRegistry = (strapi) => {
           throw new Error(`Custom field name: '${name}' is not a valid object key`);
         }
 
+        // Validate inputSize when provided
+        if (inputSize) {
+          if (
+            !isPlainObject(inputSize) ||
+            !has('default', inputSize) ||
+            !has('isResizable', inputSize)
+          ) {
+            throw new Error(`inputSize should be an object with 'default' and 'isResizable' keys`);
+          }
+          if (![4, 6, 8, 12].includes(inputSize.default)) {
+            throw new Error('Custom fields require a valid default input size');
+          }
+          if (typeof inputSize.isResizable !== 'boolean') {
+            throw new Error('Custom fields should specify if their input is resizable');
+          }
+        }
+
         // When no plugin is specified, or it isn't found in Strapi, default to global
         const uid = strapi.plugin(plugin) ? `plugin::${plugin}.${name}` : `global::${name}`;
 

package/lib/core-api/__tests__/controller.test.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { createController } = require('../controller');
+
+describe('Default Controller', () => {
+  test('Creates Collection Type default actions', () => {
+    const service = {};
+    const contentType = {
+      modelName: 'testModel',
+      kind: 'collectionType',
+    };
+
+    const controller = createController({ service, contentType });
+
+    expect(controller).toEqual({
+      find: expect.any(Function),
+      findOne: expect.any(Function),
+      create: expect.any(Function),
+      update: expect.any(Function),
+      delete: expect.any(Function),
+    });
+  });
+
+  test('Creates Single Type default actions', () => {
+    const service = {};
+    const contentType = {
+      modelName: 'testModel',
+      kind: 'singleType',
+    };
+
+    const controller = createController({ service, contentType });
+
+    expect(controller).toEqual({
+      find: expect.any(Function),
+      update: expect.any(Function),
+      delete: expect.any(Function),
+    });
+  });
+});

package/lib/core-api/controller/__tests__/transform.test.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const transforms = require('../transform');
+
+describe('Transforms', () => {
+  test('Leaves nil values untouched', () => {
+    expect(transforms.transformResponse()).toBeUndefined();
+    expect(transforms.transformResponse(null)).toBe(null);
+  });
+
+  test('Throws if entry is not and object or an array of object', () => {
+    expect(() => transforms.transformResponse(0)).toThrow();
+    expect(() => transforms.transformResponse(new Date())).toThrow();
+    expect(() => transforms.transformResponse('azaz')).toThrow();
+  });
+
+  test('Handles arrays of entries', () => {
+    expect(transforms.transformResponse([{ id: 1, title: 'Hello' }])).toStrictEqual({
+      data: [{ id: 1, attributes: { title: 'Hello' } }],
+      meta: {},
+    });
+  });
+
+  test('Handles single entry', () => {
+    expect(transforms.transformResponse({ id: 1, title: 'Hello' })).toStrictEqual({
+      data: { id: 1, attributes: { title: 'Hello' } },
+      meta: {},
+    });
+  });
+
+  test('Accepts any meta', () => {
+    const someMeta = { foo: 'bar' };
+    expect(transforms.transformResponse({ id: 1, title: 'Hello' }, someMeta)).toStrictEqual({
+      data: { id: 1, attributes: { title: 'Hello' } },
+      meta: someMeta,
+    });
+  });
+
+  test('Handles relations single value', () => {
+    const contentType = {
+      attributes: {
+        relation: {
+          type: 'relation',
+          target: 'xxx',
+        },
+      },
+    };
+
+    global.strapi = {
+      contentType() {
+        return undefined;
+      },
+    };
+
+    expect(
+      transforms.transformResponse(
+        { id: 1, title: 'Hello', relation: { id: 1, value: 'test' } },
+        undefined,
+        { contentType }
+      )
+    ).toStrictEqual({
+      data: {
+        id: 1,
+        attributes: {
+          title: 'Hello',
+          relation: {
+            data: {
+              id: 1,
+              attributes: {
+                value: 'test',
+              },
+            },
+          },
+        },
+      },
+      meta: {},
+    });
+  });
+
+  test('Handles relations array value', () => {
+    const contentType = {
+      attributes: {
+        relation: {
+          type: 'relation',
+          target: 'xxx',
+        },
+      },
+    };
+
+    global.strapi = {
+      contentType() {
+        return undefined;
+      },
+    };
+
+    expect(
+      transforms.transformResponse(
+        { id: 1, title: 'Hello', relation: [{ id: 1, value: 'test' }] },
+        undefined,
+        { contentType }
+      )
+    ).toStrictEqual({
+      data: {
+        id: 1,
+        attributes: {
+          title: 'Hello',
+          relation: {
+            data: [
+              {
+                id: 1,
+                attributes: {
+                  value: 'test',
+                },
+              },
+            ],
+          },
+        },
+      },
+      meta: {},
+    });
+  });
+
+  test('Handles relations recursively', () => {
+    const contentType = {
+      attributes: {
+        relation: {
+          type: 'relation',
+          target: 'xxx',
+        },
+      },
+    };
+
+    global.strapi = {
+      contentType() {
+        return {
+          attributes: {
+            nestedRelation: {
+              type: 'relation',
+              target: 'xxxx',
+            },
+          },
+        };
+      },
+    };
+
+    expect(
+      transforms.transformResponse(
+        {
+          id: 1,
+          title: 'Hello',
+          relation: [{ id: 1, value: 'test', nestedRelation: { id: 2, foo: 'bar' } }],
+        },
+        undefined,
+        { contentType }
+      )
+    ).toStrictEqual({
+      data: {
+        id: 1,
+        attributes: {
+          title: 'Hello',
+          relation: {
+            data: [
+              {
+                id: 1,
+                attributes: {
+                  value: 'test',
+                  nestedRelation: {
+                    data: {
+                      id: 2,
+                      attributes: {
+                        foo: 'bar',
+                      },
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+      meta: {},
+    });
+  });
+
+  test('Handles media like relations', () => {
+    const contentType = {
+      attributes: {
+        media: {
+          type: 'media',
+        },
+      },
+    };
+
+    global.strapi = {
+      contentType() {
+        return undefined;
+      },
+    };
+
+    expect(
+      transforms.transformResponse(
+        { id: 1, title: 'Hello', media: [{ id: 1, value: 'test' }] },
+        undefined,
+        { contentType }
+      )
+    ).toStrictEqual({
+      data: {
+        id: 1,
+        attributes: {
+          title: 'Hello',
+          media: {
+            data: [
+              {
+                id: 1,
+                attributes: {
+                  value: 'test',
+                },
+              },
+            ],
+          },
+        },
+      },
+      meta: {},
+    });
+  });
+});

package/lib/core-api/service/__tests__/index.test.js

@@ -0,0 +1,127 @@
+'use strict';
+
+const { createService } = require('../index');
+
+describe('Default Service', () => {
+  describe('Collection Type', () => {
+    test('Creates default actions', () => {
+      const contentType = {
+        modelName: 'testModel',
+        kind: 'collectionType',
+      };
+
+      const service = createService({ contentType });
+
+      expect(service).toEqual({
+        find: expect.any(Function),
+        findOne: expect.any(Function),
+        create: expect.any(Function),
+        update: expect.any(Function),
+        delete: expect.any(Function),
+      });
+    });
+  });
+
+  describe('Single Type', () => {
+    test('Creates default actions', () => {
+      const contentType = {
+        modelName: 'testModel',
+        kind: 'singleType',
+      };
+
+      const service = createService({ contentType });
+
+      expect(service).toEqual({
+        find: expect.any(Function),
+        createOrUpdate: expect.any(Function),
+        delete: expect.any(Function),
+      });
+    });
+
+    describe('Passes the logic down to the entityService', () => {
+      test('Creates data when no entity is found', async () => {
+        global.strapi = {
+          entityService: {
+            findMany: jest.fn(() => Promise.resolve(null)),
+            create: jest.fn(() => Promise.resolve({ id: 1 })),
+          },
+          query() {
+            return { count() {} };
+          },
+        };
+
+        const contentType = {
+          uid: 'testModel',
+          kind: 'singleType',
+        };
+
+        const service = createService({ contentType });
+
+        const input = {};
+        await service.createOrUpdate({ data: input });
+
+        expect(strapi.entityService.findMany).toHaveBeenCalledWith('testModel', {
+          publicationState: 'preview',
+        });
+
+        expect(strapi.entityService.create).toHaveBeenCalledWith('testModel', { data: input });
+      });
+
+      test('Updates data when entity is found', async () => {
+        global.strapi = {
+          entityService: {
+            findMany: jest.fn(() => Promise.resolve({ id: 1 })),
+            update: jest.fn(() => Promise.resolve({ id: 1 })),
+          },
+          query() {
+            return { count() {} };
+          },
+        };
+
+        const contentType = {
+          uid: 'testModel',
+          kind: 'singleType',
+        };
+
+        const service = createService({ contentType });
+
+        const input = {};
+        await service.createOrUpdate({ data: input });
+
+        expect(strapi.entityService.findMany).toHaveBeenCalledWith('testModel', {
+          populate: undefined,
+          publicationState: 'preview',
+        });
+
+        expect(strapi.entityService.update).toHaveBeenCalledWith('testModel', 1, {
+          data: input,
+        });
+      });
+
+      test('Delete data when entity is found', async () => {
+        global.strapi = {
+          entityService: {
+            findMany: jest.fn(() => Promise.resolve({ id: 1 })),
+            delete: jest.fn(() => Promise.resolve({ id: 1 })),
+          },
+        };
+
+        const contentType = {
+          uid: 'testModel',
+          kind: 'singleType',
+        };
+
+        const service = createService({ contentType });
+
+        await service.delete();
+
+        expect(strapi.entityService.findMany).toHaveBeenCalledWith('testModel', {
+          populate: undefined,
+          publicationState: 'live',
+        });
+
+        expect(strapi.entityService.delete).toHaveBeenCalledWith('testModel', 1);
+      });
+    });
+  });
+});