@localazy/strapi-plugin 0.1.0

package/server/utils/__tests__/pick-entries.test.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const pickEntries = require("../pick-entries");
+const restaurantFlattened = require("../../tests/fixtures/restaurant-flattened");
+const collectionFlattened = require("../../tests/fixtures/collection-flattened");
+const restaurantsPickPaths = require("../../tests/fixtures/restaurants-pick-paths");
+
+describe("pick entries test suite", () => {
+  it("should return picked entries from 1 restaurant", () => {
+    // SETUP
+    const entry = restaurantFlattened;
+    const pickPaths = [
+      "api::restaurant.restaurant.title",
+      "api::restaurant.restaurant.description",
+      "api::restaurant.restaurant.street",
+      "api::restaurant.restaurant.city",
+      "api::restaurant.restaurant.country",
+      "api::restaurant.restaurant.id",
+    ];
+
+    // EXECUTE
+    const result = pickEntries(entry, pickPaths);
+
+    // VERIFY
+    const expected = {
+      "api::restaurant.restaurant[3].city": "Testow",
+      "api::restaurant.restaurant[3].country": "Test Rep.",
+      "api::restaurant.restaurant[3].description":
+        "With some great description",
+      "api::restaurant.restaurant[3].street": "Testowa",
+      "api::restaurant.restaurant[3].title": "Full Restaurant",
+    };
+    expect(result).toEqual(expected);
+  });
+
+  it("should return picked entries from collection", () => {
+    // SETUP
+    const entry = collectionFlattened;
+    const pickPaths = restaurantsPickPaths("api::restaurant.restaurant");
+
+    // EXECUTE
+    const result = pickEntries(entry, pickPaths);
+
+    // VERIFY
+    const expected = {
+      "api::restaurant.restaurant[1].description": "Restaurant 1 description",
+      "api::restaurant.restaurant[1].descs[1].rich_description":
+        "restaurant 1 rich_desc",
+      "api::restaurant.restaurant[1].title": "Restaurant 1",
+      "api::restaurant.restaurant[2].description": "Restaurant 2 description",
+      "api::restaurant.restaurant[2].title": "Restaurant 2",
+      "api::restaurant.restaurant[3].city": "Testow",
+      "api::restaurant.restaurant[3].country": "Test Rep.",
+      "api::restaurant.restaurant[3].description":
+        "With some great description",
+      "api::restaurant.restaurant[3].descs[3].excerpt": "Est. 2022",
+      "api::restaurant.restaurant[3].descs[3].history":
+        "Est. 2022, based in NY, NY",
+      "api::restaurant.restaurant[3].descs[3].rich_description":
+        "Another restaurant desc",
+      "api::restaurant.restaurant[3].descs[3].test_variants[5].name":
+        "no such thing...",
+      "api::restaurant.restaurant[3].recipes[2].ingredients[4].name": "Beef",
+      "api::restaurant.restaurant[3].recipes[2].ingredients[5].name": "Water",
+      "api::restaurant.restaurant[3].recipes[2].name": "Beef Broth",
+      "api::restaurant.restaurant[3].recipes[3].ingredients[2].name": "Tomato",
+      "api::restaurant.restaurant[3].recipes[3].ingredients[3].name": "Soup",
+      "api::restaurant.restaurant[3].recipes[3].name": "Tomato Soup",
+      "api::restaurant.restaurant[3].recipes[3].variants[4].name":
+        "Red, yellow, green",
+      "api::restaurant.restaurant[3].recipes[4].ingredients[6].name":
+        "Beef meat",
+      "api::restaurant.restaurant[3].recipes[4].ingredients[7].name": "Pepper",
+      "api::restaurant.restaurant[3].recipes[4].ingredients[8].name":
+        "Pepper spices",
+      "api::restaurant.restaurant[3].recipes[4].ingredients[9].name": "Water",
+      "api::restaurant.restaurant[3].recipes[4].name": "Goulash",
+      "api::restaurant.restaurant[3].street": "Testowa",
+      "api::restaurant.restaurant[3].title": "Full Restaurant",
+    };
+    expect(result).toEqual(expected);
+  });
+});

package/server/utils/build-populate.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const set = require("lodash/set");
+
+const getPopulateObject = (keys) => {
+  const populate = {};
+  for (const key of keys) {
+    set(populate, key, "*");
+  }
+
+  return populate;
+};
+
+const buildPopulate = (models, modelUid) => {
+  const buildPopulateStep = (models, modelUid, prefix = "") => {
+    const model = models.find((model) => model.uid === modelUid);
+
+    if (!model || !model.attributes) {
+      return getPopulateObject(keys);
+    }
+
+    for (const [attributeName, attribute] of Object.entries(model.attributes)) {
+      if (attribute.type === "component") {
+        const key = prefix
+          ? `${prefix}.${attributeName}.populate`
+          : `${attributeName}.populate`;
+        keys.push(key);
+        const newPrefix = prefix
+          ? `${prefix}.${attributeName}`
+          : `${attributeName}`;
+        const innerModelUid = attribute.component;
+        buildPopulateStep(models, innerModelUid, newPrefix);
+      }
+    }
+
+    return getPopulateObject(keys);
+  };
+  const keys = ["populate"];
+
+  return buildPopulateStep(models, modelUid);
+};
+
+module.exports = buildPopulate;

package/server/utils/delay.js

@@ -0,0 +1,6 @@
+"use strict";
+
+// eslint-disable-next-line no-promise-executor-return
+const delay = (ms = 150) => new Promise((resolve) => setTimeout(resolve, ms));
+
+module.exports = delay;

package/server/utils/flatten-object.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const flattenObject = (object, prefix = "") => {
+  const result = {};
+
+  for (const objectKey in object) {
+    if (objectKey === "id") {
+      continue;
+    }
+
+    if (typeof object[objectKey] !== "object") {
+      const key = prefix ? `${prefix}.${objectKey}` : objectKey;
+      // Simple leaf (e.g. string or number)
+      result[key] = object[objectKey];
+    } else {
+      // Recursive call down to flattened object
+      let flatObject;
+
+      // If it is an array then turn it into an object with the correct keys
+      if (Array.isArray(object[objectKey])) {
+        // Reduce each item into the right key
+        const flattenedArray = object[objectKey].reduce(
+          (accumulator, item, index) => {
+            // No id should use the index of the array item
+            accumulator[`${objectKey}[${item.id || index}]`] =
+              flattenObject(item);
+            return accumulator;
+          },
+          {}
+        );
+
+        // Then flatten it
+        flatObject = flattenObject(flattenedArray);
+      } else {
+        // Otherwise it is a complex object so you want to flatten that
+        // but with the prefix of this current object key
+        const suffix = object[objectKey]?.id
+          ? `${objectKey}[${object[objectKey].id}]`
+          : objectKey;
+        flatObject = flattenObject(object[objectKey], suffix);
+      }
+
+      for (const flatObjectKey in flatObject) {
+        const key = prefix ? `${prefix}.${flatObjectKey}` : flatObjectKey;
+        result[`${key}`] = flatObject[flatObjectKey];
+      }
+    }
+  }
+  return result;
+};
+
+module.exports = flattenObject;

package/server/utils/get-localazy-api.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const LocalazyApi = require("@localazy/ts-api").default;
+const { LOCALAZY_PUBLIC_API_URL } = require("../config").default;
+
+module.exports = async () => {
+  const user = await strapi
+    .plugin("localazy")
+    .service("localazyUserService")
+    .getUser();
+
+  const { accessToken } = user;
+  if (!accessToken) {
+    throw new Error("Localazy user is not logged in.");
+  }
+
+  const api = LocalazyApi({
+    projectToken: accessToken,
+    baseUrl: LOCALAZY_PUBLIC_API_URL,
+  });
+  return api;
+};

package/server/utils/get-main-keys-of-nested-array-objects.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = (array) => {
+  return array.map((item) => Object.keys(item)[0]);
+};

package/server/utils/get-models-tree.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const getModelTree = (attributes, models) => {
+  const currentModelTree = {};
+  for (const attribute in attributes) {
+    if (attributes[attribute].type === "component") {
+      const nestedModel = models.find(
+        (model) => model.uid === attributes[attribute].component
+      );
+
+      currentModelTree[attribute] = {
+        ...getModelTree(nestedModel.__schema__.attributes, models),
+      };
+    } else if (
+      ["string", "text", "richtext"].includes(attributes[attribute].type)
+    ) {
+      currentModelTree[attribute] = false;
+    } else {
+      currentModelTree[attribute] = null;
+    }
+  }
+
+  return currentModelTree;
+};
+
+/**
+ * Kinds of models ["collectionType", "singleType"] are expected by the function.
+ */
+const getModelsTree = (models) => {
+  const modelsTree = [];
+  for (const model of models) {
+    const modelTree = {
+      [model.__schema__.collectionName]: {
+        __model__: true,
+        ...getModelTree(model.__schema__.attributes, models),
+      },
+    };
+    modelsTree.push(modelTree);
+  }
+  return modelsTree;
+};
+
+module.exports = getModelsTree;

package/server/utils/intl-display-name.js

@@ -0,0 +1,7 @@
+const { isoStrapiToLocalazy } = require("./iso-locales-utils.js");
+
+module.exports = (isoCode) => {
+  const isoDashed = isoStrapiToLocalazy(isoCode);
+  let languageNames = new Intl.DisplayNames(["en"], { type: "language" });
+  return languageNames.of(isoDashed);
+};

package/server/utils/is-generally-applicable-content-type.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const SUPPORTED_MODEL_TYPES = ["contentType", "component"];
+const UNSUPPORTED_UID_PREFIXES = [
+  "strapi::core",
+  "plugin::users-permissions.user",
+];
+
+module.exports = (model) => {
+  for (const prefix of UNSUPPORTED_UID_PREFIXES) {
+    if (model.uid.includes(prefix)) {
+      return false;
+    }
+  }
+
+  if (!SUPPORTED_MODEL_TYPES.includes(model.modelType)) {
+    return false;
+  }
+
+  // is not applicable
+  // eslint-disable-next-line no-underscore-dangle
+  if (!model.__schema__) {
+    return false;
+  }
+
+  if (model.pluginOptions) {
+    if (model.pluginOptions["content-type-builder"]) {
+      return model.pluginOptions["content-type-builder"].visible;
+    }
+  }
+
+  return true;
+};

package/server/utils/is-localazy-applicable-content-type.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const isGenerallyApplicableContentType = require("./is-generally-applicable-content-type");
+
+module.exports = (model) => {
+  const isGenerallyApplicable = isGenerallyApplicableContentType(model);
+  if (!isGenerallyApplicable) {
+    return false;
+  }
+
+  // cannot be translatable
+  if (!model.pluginOptions) {
+    return false;
+  }
+
+  // cannot be translatable
+  if (!model.pluginOptions) {
+    return false;
+  }
+
+  if (model.pluginOptions) {
+    // cannot be translatable
+    if (!model.pluginOptions["i18n"]) {
+      return false;
+    }
+
+    // decide whether it is translatable
+    if (model.pluginOptions["i18n"]) {
+      return model.pluginOptions["i18n"].localized
+        ? model.pluginOptions["i18n"].localized
+        : false;
+    }
+  }
+
+  return true;
+};

package/server/utils/iso-locales-utils.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const isoStrapiToLocalazy = (isoStrapi) => {
+  if (!isoStrapi) {
+    return null;
+  }
+
+  return isoStrapi.replace("_", "-");
+};
+
+const isoLocalazyToStrapi = (isoLocalazy) => {
+  if (!isoLocalazy) {
+    return null;
+  }
+
+  return isoLocalazy.replace("-", "_");
+};
+
+module.exports = {
+  isoStrapiToLocalazy,
+  isoLocalazyToStrapi,
+};

package/server/utils/objectivise-entry.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const set = require("lodash/set");
+
+const arrayToObject = (array, keyField) =>
+  array.reduce((obj, item) => {
+    obj[item[keyField]] = item;
+    return obj;
+  }, {});
+
+const objectiviseEntry = (entry) => {
+  const objectivized = {};
+
+  const objectiviseEntryStep = (entryStep, prefix = "") => {
+    if (entryStep === null || typeof entryStep !== "object") {
+      set(objectivized, prefix, entryStep);
+    } else {
+      if (Array.isArray(entryStep)) {
+        const arrayedEntry = arrayToObject(entryStep, "id");
+        Object.keys(arrayedEntry).forEach((key) => {
+          objectiviseEntryStep(
+            arrayedEntry[key],
+            prefix ? `${prefix}.${key}` : key
+          );
+        });
+      } else {
+        Object.keys(entryStep).forEach((key) => {
+          objectiviseEntryStep(
+            entryStep[key],
+            prefix ? `${prefix}.${key}` : key
+          );
+        });
+      }
+    }
+  };
+  objectiviseEntryStep(entry);
+
+  return objectivized;
+};
+
+module.exports = objectiviseEntry;

package/server/utils/omit-deep.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const cloneDeepWith = require("lodash/cloneDeepWith");
+
+function omitDeep(collection, excludeKeys) {
+  function omitFn(value) {
+    if (value && typeof value === "object") {
+      excludeKeys.forEach((key) => {
+        delete value[key];
+      });
+    }
+  }
+
+  return cloneDeepWith(collection, omitFn);
+}
+
+module.exports = omitDeep;

package/server/utils/parsed-localazy-entry-to-create-entry.js

@@ -0,0 +1,115 @@
+"use strict";
+
+const set = require("lodash/set");
+
+const getAttribute = (model, attribute) => {
+  const attributeObj = model.attributes[attribute];
+  return attributeObj;
+};
+
+const isComponent = (attributeObj) => {
+  return attributeObj.type === "component";
+};
+
+const isRepeatable = (attributeObj) => {
+  return isComponent(attributeObj) && !!attributeObj.repeatable;
+};
+
+const findModel = (models, uid) => {
+  const model = models.find((model) => model.uid === uid);
+  return model;
+};
+
+const parsedLocalazyEntryToCreateEntry = (
+  models,
+  parsedLocalazyEntry,
+  uid,
+  locale = ""
+) => {
+  const createEntry = {};
+
+  const toCreateEntry = (
+    entry,
+    model,
+    // eslint-disable-next-line no-unused-vars
+    key = "",
+    prefix = "",
+    component = "",
+    isRepeatableComponent = false
+  ) => {
+    if (Array.isArray(entry)) {
+      // is array
+      let i = 0;
+      Object.entries(entry).forEach(([, value]) => {
+        if (value !== null) {
+          if (component && isRepeatableComponent) {
+            toCreateEntry(value, model, i, `${prefix}.${i}`, component);
+            i += 1;
+          }
+
+          if (component && !isRepeatableComponent) {
+            toCreateEntry(value, model, `${prefix}`, `${prefix}`);
+          }
+        }
+      });
+    } else {
+      // is object
+      Object.entries(entry).forEach(([objectKey, value]) => {
+        const attribute = getAttribute(model, objectKey);
+        if (attribute === undefined) {
+          // logicaly don't anything, skip...
+        } else if (isComponent(attribute)) {
+          // is component
+          const component = attribute.component;
+          const componentModel = findModel(models, component);
+          if (isRepeatable(attribute)) {
+            // is repeatable - array
+            const newPrefix = prefix
+              ? `${prefix}.${objectKey}`
+              : `${objectKey}`;
+            toCreateEntry(
+              value,
+              componentModel,
+              objectKey,
+              newPrefix,
+              component,
+              true
+            );
+          } else {
+            // is no repeatable - object
+            const newPrefix = prefix
+              ? `${prefix}.${objectKey}`
+              : `${objectKey}`;
+            set(createEntry, `${newPrefix}.__component`, component);
+            toCreateEntry(
+              value,
+              componentModel,
+              objectKey,
+              newPrefix,
+              component,
+              false
+            );
+          }
+        } else {
+          const newPrefix = prefix ? `${prefix}.${objectKey}` : `${objectKey}`;
+          set(createEntry, newPrefix, value);
+
+          if (component) {
+            set(createEntry, `${prefix}.__component`, component);
+          }
+          // is not component
+        }
+      });
+    }
+  };
+
+  const model = findModel(models, uid);
+  toCreateEntry(parsedLocalazyEntry, model);
+  if (locale) {
+    createEntry.locale = locale;
+  }
+
+  return createEntry;
+};
+
+module.exports = parsedLocalazyEntryToCreateEntry;

package/server/utils/parsed-localazy-entry-to-update-entry.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const merge = require("lodash/merge");
+const parsedLocalazyEntryToCreateEntry = require("./parsed-localazy-entry-to-create-entry");
+const omitDeep = require("./omit-deep");
+
+const parsedLocalazyEntryToUpdateEntry = (
+  allModels,
+  localazyEntry,
+  currentEntry,
+  uid
+) => {
+  const createEntry = parsedLocalazyEntryToCreateEntry(
+    allModels,
+    localazyEntry,
+    uid
+  );
+  let updateEntry = merge(currentEntry, createEntry);
+  updateEntry = omitDeep(updateEntry, [
+    "__component",
+    "locale",
+    "localizations",
+    "createdAt",
+    "updatedAt",
+    "publishedAt",
+  ]);
+
+  return updateEntry;
+};
+
+module.exports = parsedLocalazyEntryToUpdateEntry;

package/server/utils/pick-entries.js

@@ -0,0 +1,14 @@
+"use strict";
+
+const pickEntries = (flatten, pickPaths) => {
+  const pickedEntries = {};
+  Object.keys(flatten).forEach((key) => {
+    const filteredKey = key.replace(/\d|[[\]]+/g, "");
+    if (pickPaths.includes(filteredKey)) {
+      pickedEntries[key] = flatten[key];
+    }
+  });
+  return pickedEntries;
+};
+
+module.exports = pickEntries;

package/server/utils/transfer-setup-utils.js

@@ -0,0 +1,39 @@
+const getMainKeysOfNestedArrayObjects = require("./get-main-keys-of-nested-array-objects");
+const flattenObject = require("./flatten-object");
+
+const findSetupModelByCollectionName = (models, collectionName) => {
+  return models.find((model) => Object.keys(model)[0] === collectionName);
+};
+
+const getCollectionsNames = (setup) => {
+  return getMainKeysOfNestedArrayObjects(setup);
+};
+
+const isCollectionTransferEnabled = (models, collectionName) => {
+  const model = findSetupModelByCollectionName(models, collectionName);
+
+  if (!model || !model[collectionName]) {
+    return false;
+  }
+
+  return !!model[collectionName].__model__;
+};
+
+const getPickPaths = (transferSetupModelProps) => {
+  const flattenedObject = flattenObject(transferSetupModelProps);
+  const pickPaths = Object.keys(flattenedObject).filter(
+    (key) => flattenedObject[key] === true && key.indexOf("__model__") === -1
+  );
+
+  // id needs to be always included
+  pickPaths.push("id");
+
+  return pickPaths;
+};
+
+module.exports = {
+  findSetupModelByCollectionName,
+  getCollectionsNames,
+  isCollectionTransferEnabled,
+  getPickPaths,
+};

package/strapi-admin.js

@@ -0,0 +1,14 @@
+"use strict";
+
+// TODO: resolve if possible
+// https://medium.com/the-javascript-dojo/improving-code-readability-with-path-aliases-1a41143d7632
+// const moduleAlias = require("module-alias");
+
+// moduleAlias.addAliases({
+//   // eslint-disable-next-line node/no-path-concat
+//   "@admin": `${__dirname}/admin`,
+//   // eslint-disable-next-line node/no-path-concat
+//   "@src": `${__dirname}/admin/src`,
+// });
+
+module.exports = require("./admin/src").default;

package/strapi-server.js

@@ -0,0 +1,5 @@
+"use strict";
+
+require("isomorphic-fetch");
+
+module.exports = require("./server");