@akemona-org/strapi-plugin-i18n 3.7.0

package/tests/content-manager/list-relation.test.e2e.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const { pick } = require('lodash/fp');
+
+const { createTestBuilder } = require('../../../../test/helpers/builder');
+const { createStrapiInstance } = require('../../../../test/helpers/strapi');
+const { createAuthRequest } = require('../../../../test/helpers/request');
+
+let strapi;
+let rq;
+let data = {
+  products: [],
+  shops: [],
+};
+
+const productModel = {
+  pluginOptions: {
+    i18n: {
+      localized: true,
+    },
+  },
+  attributes: {
+    name: {
+      type: 'string',
+    },
+  },
+  connection: 'default',
+  name: 'product',
+  description: '',
+  collectionName: '',
+};
+
+const shopModel = {
+  pluginOptions: {
+    i18n: {
+      localized: true,
+    },
+  },
+  attributes: {
+    name: {
+      type: 'string',
+    },
+    products: {
+      dominant: true,
+      nature: 'manyToMany',
+      target: 'application::product.product',
+      targetAttribute: 'shops',
+    },
+  },
+  connection: 'default',
+  name: 'shop',
+};
+
+const shops = [
+  {
+    name: 'market',
+    locale: 'en',
+  },
+];
+
+const products = ({ shop }) => {
+  const shops = [shop[0].id];
+
+  const entries = [
+    {
+      name: 'pomodoro',
+      shops,
+      locale: 'it',
+    },
+    {
+      name: 'apple',
+      shops,
+      locale: 'en',
+    },
+  ];
+
+  return entries;
+};
+
+describe('i18n - Relation-list route', () => {
+  const builder = createTestBuilder();
+
+  beforeAll(async () => {
+    await builder
+      .addContentTypes([productModel, shopModel])
+      .addFixtures(shopModel.name, shops)
+      .addFixtures(productModel.name, products)
+      .build();
+
+    strapi = await createStrapiInstance();
+    rq = await createAuthRequest({ strapi });
+
+    data.shops = builder.sanitizedFixturesFor(shopModel.name, strapi);
+    data.products = builder.sanitizedFixturesFor(productModel.name, strapi);
+  });
+
+  afterAll(async () => {
+    await strapi.destroy();
+    await builder.cleanup();
+  });
+
+  test('Can filter on default locale', async () => {
+    const res = await rq({
+      method: 'POST',
+      url: '/content-manager/relations/application::shop.shop/products',
+    });
+
+    expect(res.body).toHaveLength(1);
+    expect(res.body[0]).toStrictEqual(pick(['_id', 'id', 'name'], data.products[1]));
+  });
+
+  test('Can filter on any locale', async () => {
+    const res = await rq({
+      method: 'POST',
+      url: '/content-manager/relations/application::shop.shop/products',
+      qs: { _locale: 'it' },
+    });
+
+    expect(res.body).toHaveLength(1);
+    expect(res.body[0]).toStrictEqual(pick(['_id', 'id', 'name'], data.products[0]));
+  });
+});

package/tests/graphql.test.e2e.js

@@ -0,0 +1,120 @@
+'use strict';
+
+// Helpers.
+const { createTestBuilder } = require('../../../test/helpers/builder');
+const { createStrapiInstance } = require('../../../test/helpers/strapi');
+const { createAuthRequest } = require('../../../test/helpers/request');
+
+const builder = createTestBuilder();
+let strapi;
+let rq;
+let graphqlQuery;
+let localeId;
+
+const recipesModel = {
+  attributes: {
+    name: {
+      type: 'string',
+    },
+  },
+  pluginOptions: {
+    i18n: {
+      localized: true,
+    },
+  },
+  connection: 'default',
+  name: 'recipes',
+  description: '',
+  collectionName: '',
+};
+
+describe('Test Graphql API create localization', () => {
+  beforeAll(async () => {
+    await builder.addContentType(recipesModel).build();
+
+    strapi = await createStrapiInstance();
+    rq = await createAuthRequest({ strapi });
+
+    graphqlQuery = body => {
+      return rq({
+        url: '/graphql',
+        method: 'POST',
+        body,
+      });
+    };
+
+    const locale = await strapi.query('locale', 'i18n').create({
+      code: 'fr',
+      name: 'French',
+    });
+
+    localeId = locale.id;
+  });
+
+  afterAll(async () => {
+    await strapi.query('locale', 'i18n').delete({ id: localeId });
+    await strapi.query('recipes').delete();
+    await strapi.destroy();
+    await builder.cleanup();
+  });
+
+  test('Create localization for a model with plural name', async () => {
+    const createResponse = await graphqlQuery({
+      query: /* GraphQL */ `
+        mutation createRecipe($input: createRecipeInput) {
+          createRecipe(input: $input) {
+            recipe {
+              id
+              name
+              locale
+            }
+          }
+        }
+      `,
+      variables: {
+        input: {
+          data: {
+            name: 'Recipe Name',
+          },
+        },
+      },
+    });
+
+    expect(createResponse.statusCode).toBe(200);
+    expect(createResponse.body.data.createRecipe.recipe).toMatchObject({
+      name: 'Recipe Name',
+      locale: 'en',
+    });
+
+    const recipeId = createResponse.body.data.createRecipe.recipe.id;
+
+    const createLocalizationResponse = await graphqlQuery({
+      query: /* GraphQL */ `
+        mutation createRecipeLocalization($input: updateRecipeInput!) {
+          createRecipeLocalization(input: $input) {
+            id
+            name
+            locale
+          }
+        }
+      `,
+      variables: {
+        input: {
+          where: {
+            id: recipeId,
+          },
+          data: {
+            name: 'Recipe Name fr',
+            locale: 'fr',
+          },
+        },
+      },
+    });
+
+    expect(createLocalizationResponse.statusCode).toBe(200);
+    expect(createLocalizationResponse.body.data.createRecipeLocalization).toMatchObject({
+      name: 'Recipe Name fr',
+      locale: 'fr',
+    });
+  });
+});

package/tests/locales.test.e2e.js

@@ -0,0 +1,414 @@
+'use strict';
+
+const { omit } = require('lodash/fp');
+
+const { createTestBuilder } = require('../../../test/helpers/builder');
+const { createStrapiInstance } = require('../../../test/helpers/strapi');
+const { createAuthRequest } = require('../../../test/helpers/request');
+
+const data = {
+  locales: [],
+  deletedLocales: [],
+};
+
+const omitTimestamps = omit(['updatedAt', 'createdAt', 'updated_at', 'created_at']);
+const compareLocales = (a, b) => (a.code < b.code ? -1 : 1);
+
+const productModel = {
+  pluginOptions: {
+    i18n: {
+      localized: true,
+    },
+  },
+  attributes: {
+    name: {
+      type: 'string',
+    },
+  },
+  connection: 'default',
+  name: 'product',
+  description: '',
+  collectionName: '',
+};
+
+describe('CRUD locales', () => {
+  let rq;
+  let strapi;
+  const builder = createTestBuilder();
+  let localeService;
+
+  beforeAll(async () => {
+    await builder.addContentType(productModel).build();
+
+    strapi = await createStrapiInstance();
+    rq = await createAuthRequest({ strapi });
+
+    localeService = strapi.plugins.i18n.services.locales;
+  });
+
+  afterAll(async () => {
+    await localeService.setDefaultLocale({ code: 'en' });
+
+    await strapi.destroy();
+    await builder.cleanup();
+  });
+
+  describe('Default locale', () => {
+    test('Default locale is already created', async () => {
+      let res = await rq({
+        url: '/i18n/locales',
+        method: 'GET',
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].isDefault).toBe(true);
+      data.locales.push(res.body[0]);
+    });
+  });
+
+  describe('Creation', () => {
+    test('Can create a locale', async () => {
+      const locale = {
+        name: 'French',
+        code: 'fr',
+        isDefault: false,
+      };
+
+      let res = await rq({
+        url: '/i18n/locales',
+        method: 'POST',
+        body: locale,
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toMatchObject({
+        id: expect.anything(),
+        ...locale,
+      });
+      data.locales.push(res.body);
+    });
+
+    test('Cannot create a locale if code or isDefault is missing', async () => {
+      const locale = {
+        name: 'Italian',
+      };
+
+      let res = await rq({
+        url: '/i18n/locales',
+        method: 'POST',
+        body: locale,
+      });
+
+      expect(res.statusCode).toBe(400);
+      expect(res.body).toMatchObject({
+        data: {
+          isDefault: ['isDefault is a required field'],
+          code: ['code is a required field'],
+        },
+        error: 'Bad Request',
+        message: 'ValidationError',
+        statusCode: 400,
+      });
+    });
+
+    test('Cannot create a locale if code already exists', async () => {
+      const locale = {
+        code: 'fr',
+        name: 'random name',
+        isDefault: false,
+      };
+
+      let res = await rq({
+        url: '/i18n/locales',
+        method: 'POST',
+        body: locale,
+      });
+
+      expect(res.statusCode).toBe(400);
+      expect(res.body).toMatchObject({ message: 'This locale already exists' });
+    });
+
+    test('Can create a locale even if name already exists', async () => {
+      const locale = {
+        name: 'French',
+        code: 'fr-FR',
+        isDefault: false,
+      };
+
+      let res = await rq({
+        url: '/i18n/locales',
+        method: 'POST',
+        body: locale,
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toMatchObject({
+        id: expect.anything(),
+        ...locale,
+      });
+      data.locales.push(res.body);
+    });
+
+    test('Only one locale can be default (POST)', async () => {
+      let res = await rq({
+        url: '/i18n/locales',
+        method: 'POST',
+        body: { code: 'bas', name: 'random', isDefault: true },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.isDefault).toBe(true);
+      data.locales[0].isDefault = false;
+
+      res = await rq({
+        url: '/i18n/locales',
+        method: 'POST',
+        body: { code: 'en-US', name: 'random', isDefault: true },
+      });
+      expect(res.statusCode).toBe(200);
+      expect(res.body.isDefault).toBe(true);
+
+      res = await rq({
+        url: '/i18n/locales',
+        method: 'GET',
+      });
+
+      expect(res.statusCode).toBe(200);
+      const enLocale = res.body.find(locale => locale.code === 'bas');
+      const enUsLocale = res.body.find(locale => locale.code === 'en-US');
+      expect(enLocale.isDefault).toBe(false);
+      expect(enUsLocale.isDefault).toBe(true);
+
+      data.locales.push(enLocale);
+      data.locales.push(enUsLocale);
+    });
+  });
+
+  describe('Read', () => {
+    test('Can list the locales', async () => {
+      let res = await rq({
+        url: '/i18n/locales',
+        method: 'GET',
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toHaveLength(data.locales.length);
+      expect(res.body.sort(compareLocales)).toMatchObject(
+        data.locales.slice().sort(compareLocales)
+      );
+    });
+  });
+
+  describe('Update', () => {
+    test('Can update the name of a locale', async () => {
+      const localeUpdate = {
+        name: 'French update',
+        isDefault: false,
+      };
+
+      let res = await rq({
+        url: `/i18n/locales/${data.locales[1].id}`,
+        method: 'PUT',
+        body: localeUpdate,
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toMatchObject({
+        ...omitTimestamps(data.locales[1]),
+        ...localeUpdate,
+      });
+      data.locales[1] = res.body;
+    });
+
+    test('Cannot update the code of a locale (without name)', async () => {
+      const localeUpdate = {
+        code: 'ak',
+      };
+
+      let res = await rq({
+        url: `/i18n/locales/${data.locales[0].id}`,
+        method: 'PUT',
+        body: localeUpdate,
+      });
+
+      expect(res.statusCode).toBe(400);
+      expect(res.body).toMatchObject({
+        data: {
+          '': ['this field has unspecified keys: code'],
+        },
+        error: 'Bad Request',
+        message: 'ValidationError',
+        statusCode: 400,
+      });
+    });
+
+    test('Cannot update the code of a locale (with name)', async () => {
+      const localeUpdate = {
+        name: 'French',
+        code: 'ak',
+      };
+
+      let res = await rq({
+        url: `/i18n/locales/${data.locales[0].id}`,
+        method: 'PUT',
+        body: localeUpdate,
+      });
+
+      expect(res.statusCode).toBe(400);
+      expect(res.body).toMatchObject({
+        data: {
+          '': ['this field has unspecified keys: code'],
+        },
+        error: 'Bad Request',
+        message: 'ValidationError',
+        statusCode: 400,
+      });
+    });
+
+    test('Only one locale can be default (PUT)', async () => {
+      let res = await rq({
+        url: `/i18n/locales/${data.locales[0].id}`,
+        method: 'PUT',
+        body: { isDefault: true },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.isDefault).toBe(true);
+
+      res = await rq({
+        url: `/i18n/locales/${data.locales[1].id}`,
+        method: 'PUT',
+        body: { isDefault: true },
+      });
+      expect(res.statusCode).toBe(200);
+      expect(res.body.isDefault).toBe(true);
+
+      res = await rq({
+        url: '/i18n/locales',
+        method: 'GET',
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.find(locale => locale.code === data.locales[0].code).isDefault).toBe(false);
+      expect(res.body.find(locale => locale.code === data.locales[1].code).isDefault).toBe(true);
+    });
+
+    test('Cannot unselect isDefault', async () => {
+      let res = await rq({
+        url: `/i18n/locales/${data.locales[0].id}`,
+        method: 'PUT',
+        body: { isDefault: true },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.isDefault).toBe(true);
+
+      res = await rq({
+        url: `/i18n/locales/${data.locales[0].id}`,
+        method: 'PUT',
+        body: { isDefault: false },
+      });
+      expect(res.statusCode).toBe(200);
+      expect(res.body.isDefault).toBe(true);
+    });
+  });
+
+  describe('Delete', () => {
+    test('Cannot delete default locale', async () => {
+      let res = await rq({
+        url: `/i18n/locales/${data.locales[0].id}`,
+        method: 'PUT',
+        body: { isDefault: true },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body.isDefault).toBe(true);
+      data.locales[1].isDefault = false;
+
+      res = await rq({
+        url: `/i18n/locales/${data.locales[0].id}`,
+        method: 'DELETE',
+      });
+      expect(res.statusCode).toBe(400);
+      expect(res.body.message).toBe('Cannot delete the default locale');
+    });
+
+    test('Simply delete a locale', async () => {
+      const res = await rq({
+        url: `/i18n/locales/${data.locales[1].id}`,
+        method: 'DELETE',
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toMatchObject(omitTimestamps(data.locales[1]));
+      data.deletedLocales.push(res.body);
+      data.locales.splice(1, 1);
+    });
+
+    test('Delete a locale and entities in this locale', async () => {
+      const { body: frenchProduct } = await rq({
+        url: '/content-manager/collection-types/application::product.product',
+        method: 'POST',
+        qs: { plugins: { i18n: { locale: 'fr-FR' } } },
+        body: { name: 'product name' },
+      });
+
+      await rq({
+        url: '/content-manager/collection-types/application::product.product',
+        method: 'POST',
+        qs: { plugins: { i18n: { locale: 'en', relatedEntityId: frenchProduct.id } } },
+        body: { name: 'product name' },
+      });
+
+      const {
+        body: { results: createdProducts },
+      } = await rq({
+        url: '/content-manager/collection-types/application::product.product',
+        method: 'GET',
+        qs: { _locale: 'fr-FR' },
+      });
+
+      expect(createdProducts).toHaveLength(1);
+      expect(createdProducts[0].localizations[0].locale).toBe('en');
+
+      const res = await rq({
+        url: `/i18n/locales/${data.locales[1].id}`,
+        method: 'DELETE',
+      });
+
+      const {
+        body: { results: frenchProducts },
+      } = await rq({
+        url: '/content-manager/collection-types/application::product.product',
+        method: 'GET',
+        qs: { _locale: 'fr-FR' },
+      });
+      expect(frenchProducts).toHaveLength(0);
+
+      const {
+        body: { results: englishProducts },
+      } = await rq({
+        url: '/content-manager/collection-types/application::product.product',
+        method: 'GET',
+        qs: { _locale: 'en' },
+      });
+      expect(englishProducts).toHaveLength(1);
+
+      expect(res.statusCode).toBe(200);
+      expect(res.body).toMatchObject(omitTimestamps(data.locales[1]));
+      data.deletedLocales.push(res.body);
+      data.locales.splice(1, 1);
+    });
+
+    test('Cannot delete not found locale', async () => {
+      let res = await rq({
+        url: `/i18n/locales/${data.deletedLocales[0].id}`,
+        method: 'DELETE',
+      });
+
+      expect(res.statusCode).toBe(404);
+      expect(res.body.message).toBe('locale.notFound');
+    });
+  });
+});

package/utils/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { prop } = require('lodash/fp');
+
+const getCoreStore = () =>
+  strapi.store({
+    environment: '',
+    type: 'plugin',
+    name: 'i18n',
+  });
+
+// retrieve a local service
+const getService = name => {
+  return prop(`i18n.services.${name}`, strapi.plugins);
+};
+
+module.exports = {
+  getService,
+  getCoreStore,
+};

package/validation/content-types.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+const { get } = require('lodash/fp');
+
+const handleReject = (error) => Promise.reject(formatYupErrors(error));
+
+const validateGetNonLocalizedAttributesSchema = yup
+  .object()
+  .shape({
+    model: yup.string().required(),
+    id: yup.mixed().when('model', {
+      is: (model) => get('kind', strapi.getModel(model)) === 'singleType',
+      then: yup.strapiID().nullable(),
+      otherwise: yup.strapiID().required(),
+    }),
+    locale: yup.string().required(),
+  })
+  .noUnknown()
+  .required();
+
+const validateGetNonLocalizedAttributesInput = (data) => {
+  return validateGetNonLocalizedAttributesSchema
+    .validate(data, { strict: true, abortEarly: false })
+    .catch(handleReject);
+};
+
+module.exports = {
+  validateGetNonLocalizedAttributesInput,
+};