@localazy/strapi-plugin 0.2.12 → 1.0.0-beta.0

package/server/utils/model-utils.js

@@ -1,43 +0,0 @@
-"use strict";
-
-const isEmpty = require("lodash/isEmpty");
-
-const getAttribute = (model, attribute) => {
-  if (isEmpty(model)) {
-    return undefined;
-  }
-
-  const attributeObj = model.attributes[attribute];
-  return attributeObj;
-};
-
-const isComponent = (attributeObj) => {
-  return attributeObj.type === "component";
-};
-
-const isDynamicZone = (attributeObj) => {
-  return attributeObj.type === "dynamiczone";
-}
-
-const isRepeatable = (attributeObj) => {
-  return isComponent(attributeObj) && !!attributeObj.repeatable;
-};
-
-const isRelation = (attributeObj) => {
-  return attributeObj.type === "relation"
-    && attributeObj.target !== "plugin::upload.file";
-};
-
-const findModel = (models, uid) => {
-  const model = models.find((model) => model.uid === uid);
-  return model;
-};
-
-module.exports = {
-  getAttribute,
-  isComponent,
-  isDynamicZone,
-  isRepeatable,
-  isRelation,
-  findModel,
-};

package/server/utils/objectivise-entry.js

@@ -1,41 +0,0 @@
-"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

@@ -1,24 +0,0 @@
-"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];
-      });
-    }
-  }
-
-  if (Array.isArray(collection)) {
-    const clonedData = [];
-    for (const collectionItem of collection) {
-      clonedData.push(cloneDeepWith(collectionItem, omitFn));
-    }
-    return clonedData;
-  }
-  return cloneDeepWith(collection, omitFn);
-}
-
-module.exports = omitDeep;

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

@@ -1,194 +0,0 @@
-"use strict";
-
-const set = require("lodash/set");
-const get = require("lodash/get");
-const resetArrayKeysDeep = require("./reset-array-keys-deep");
-const { getAttribute, isComponent, isDynamicZone, isRepeatable, findModel } = require("./model-utils");
-
-const parsedLocalazyEntryToCreateEntry = (
-  models,
-  parsedLocalazyEntry,
-  baseEntry,
-  uid,
-  locale = ""
-) => {
-  const createEntry = {};
-  const repeatableComponentsKeystoFilter = [];
-  const dynamicZoneComponentKeys = [];
-
-  const toCreateEntry = (
-    entry,
-    model,
-    // eslint-disable-next-line no-unused-vars
-    key = "",
-    prefix = "",
-    component = "",
-    isRepeatableComponent = false,
-    isDZ = false,
-    isInsideDZ = false,
-  ) => {
-    if (Array.isArray(entry)) {
-      // is array
-      Object.entries(entry).forEach(([baseEntryItemId, value]) => {
-        if (value !== null) {
-          if (component && isRepeatableComponent) {
-            // used for indices filtering in repeatable components
-            if (!repeatableComponentsKeystoFilter.includes(prefix)) {
-              repeatableComponentsKeystoFilter.push(prefix);
-            }
-            const baseEntryRepeatableItemId = parseInt(baseEntryItemId);
-            const baseEntryRepeateableGroup = get(baseEntry, prefix);
-            if (baseEntryRepeateableGroup !== undefined) {
-              const localizedEntryRepeatableItemPosition = baseEntryRepeateableGroup.findIndex((repeatableItem) => !!repeatableItem && repeatableItem.id === baseEntryRepeatableItemId);
-              if (localizedEntryRepeatableItemPosition > -1) {
-                toCreateEntry(value, model, localizedEntryRepeatableItemPosition, `${prefix}.${localizedEntryRepeatableItemPosition}`, component);
-              }
-            }
-          }
-
-          if (component && !isRepeatableComponent) {
-            toCreateEntry(value, model, `${prefix}`, `${prefix}`);
-          }
-
-          if (!component && isRepeatableComponent) {
-            // used for indices filtering in dynamic zones
-            if (!repeatableComponentsKeystoFilter.includes(prefix)) {
-              repeatableComponentsKeystoFilter.push(prefix);
-            }
-            const baseEntryRepeatableItemId = parseInt(baseEntryItemId);
-            const baseEntryRepeateableGroup = get(baseEntry, prefix);
-            if (baseEntryRepeateableGroup !== undefined) {
-              const localizedEntryRepeatableItemPosition = baseEntryRepeateableGroup.findIndex((repeatableItem) => !!repeatableItem && repeatableItem.id === baseEntryRepeatableItemId);
-              if (localizedEntryRepeatableItemPosition > -1) {
-                const dzEntry = get(baseEntry, prefix).find((v) => v.id === baseEntryRepeatableItemId);
-                const dzEntryComponent = dzEntry.__component;
-                const dzEntryComponentModel = findModel(models, dzEntryComponent);
-                toCreateEntry(
-                  value,
-                  dzEntryComponentModel,
-                  localizedEntryRepeatableItemPosition,
-                  `${prefix}.${localizedEntryRepeatableItemPosition}`,
-                  dzEntryComponent,
-                  true,
-                  true,
-                );
-              }
-            }
-          }
-        }
-      });
-    } else if (isDZ) {
-      Object.entries(entry).forEach(([dzEntryIdWithComponent, value]) => {
-        let [dzEntryId, dzEntryComponent] = dzEntryIdWithComponent.split(";");
-        dzEntryId = parseInt(dzEntryId);
-        const baseEntryDZEntry = get(baseEntry, prefix).find((v) => (v.id === dzEntryId) && (v.__component === dzEntryComponent));
-        if (baseEntryDZEntry !== undefined) {
-          const dzEntryComponentModel = findModel(models, dzEntryComponent);
-          toCreateEntry(
-            value,
-            dzEntryComponentModel,
-            dzEntryId,
-            `${prefix}.${dzEntryId}`,
-            dzEntryComponent,
-            true,
-            false, // we're already inside, so it's falsy
-            true,
-          );
-        }
-        /**
-         * Don't do anything if `baseEntryDZEntry` is `undefined` - it means that the entry was deleted
-         * That also automatically presumes that deal with `undefined` `baseEntryDZIndex` inside the Dynamic Zone
-         */
-      });
-    } 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 innerComponent = attribute.component;
-          const componentModel = findModel(models, innerComponent);
-
-          let newPrefixBase = prefix;
-          let newPrefix = newPrefixBase
-            ? `${newPrefixBase}.${objectKey}`
-            : `${objectKey}`;
-          if (isInsideDZ) {
-            let [dzParamKey, dzEntryId] = newPrefixBase.split(".");
-            dzEntryId = parseInt(dzEntryId);
-            const baseEntryDZIndex = get(baseEntry, dzParamKey).findIndex((v) => (v.__component === component) && (v.id === dzEntryId));
-            newPrefixBase = `${dzParamKey}.${baseEntryDZIndex}`;
-            newPrefix = `${newPrefixBase}.${objectKey}`;
-          }
-          const isRepeatableComponent = isRepeatable(attribute);
-          if (!isRepeatableComponent) {
-            set(createEntry, `${newPrefix}.__component`, innerComponent);
-          }
-          toCreateEntry(
-            value,
-            componentModel,
-            objectKey,
-            newPrefix,
-            innerComponent,
-            isRepeatableComponent,
-            false,
-            isInsideDZ,
-          );
-        } else if (isDynamicZone(attribute)) {
-          // behaves sort of like repeatable component
-          const newPrefix = prefix
-            ? `${prefix}.${objectKey}`
-            : `${objectKey}`;
-          toCreateEntry(
-            value,
-            null, // model is evaluated later as it's dynamic (DZ)
-            objectKey,
-            newPrefix,
-            "", // component is computed later as it's dynamic (DZ)
-            true,
-            true,
-          );
-        } else {
-          let newPrefixBase = prefix;
-          let newPrefix = newPrefixBase ? `${newPrefixBase}.${objectKey}` : `${objectKey}`;
-          if (isInsideDZ) {
-            let [dzParamKey, dzEntryId] = newPrefixBase.split(".");
-            dzEntryId = parseInt(dzEntryId);
-            const baseEntryDZIndex = get(baseEntry, dzParamKey).findIndex((v) => (v.__component === component) && (v.id === dzEntryId));
-            newPrefixBase = `${dzParamKey}.${baseEntryDZIndex}`;
-            newPrefix = `${newPrefixBase}.${objectKey}`;
-          }
-          set(createEntry, newPrefix, value);
-
-          if (component) {
-            const componentKeyToSet = `${newPrefixBase}.__component`;
-            set(createEntry, componentKeyToSet, component);
-
-            if (isInsideDZ) {
-              const isKeyAdded = (typeof dynamicZoneComponentKeys.find((v) => v.key === componentKeyToSet) !== "undefined");
-              if (!isKeyAdded)
-                dynamicZoneComponentKeys.push({
-                  key: componentKeyToSet,
-                  component,
-                });
-            }
-          }
-          // is not component
-        }
-      });
-    }
-  };
-
-  const model = findModel(models, uid);
-  toCreateEntry(parsedLocalazyEntry, model);
-  if (locale) {
-    createEntry.locale = locale;
-  }
-
-  resetArrayKeysDeep(createEntry, repeatableComponentsKeystoFilter);
-  return { createEntry, dynamicZoneComponentKeys };
-};
-
-module.exports = parsedLocalazyEntryToCreateEntry;

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

@@ -1,83 +0,0 @@
-"use strict";
-
-const merge = require("lodash/merge");
-const parsedLocalazyEntryToCreateEntry = require("./parsed-localazy-entry-to-create-entry");
-const omitDeep = require("./omit-deep");
-const populateCreateUpdateEntryWithBaseEntry = require("./populate-create-update-entry-with-base-entry");
-const { set } = require("lodash");
-
-const parsedLocalazyEntryToUpdateEntry = async (
-  allModels,
-  localazyEntry,
-  fullyPopulatedLocalizedEntry,
-  currentEntry,
-  baseEntry,
-  uid,
-  locale
-) => {
-  const { createEntry, dynamicZoneComponentKeys } = parsedLocalazyEntryToCreateEntry(
-    allModels,
-    localazyEntry,
-    baseEntry,
-    uid
-  );
-
-  /**
-   * TODO: possibly improve for the following case:
-   * A `key` is deleted from the base entry, and the same `key` still exist in the localized entry.
-   * Even though the `key` is deprecated in Localazy, it concludes that the `key` is still used in the localized entry.
-   * Therefore, it leads to an error when updating the entry.
-   *
-   * The solution for now: Delete the localized entry and re-download to force the creation process.
-   */
-  let updateEntry = {};
-  merge(updateEntry, currentEntry, createEntry);
-  updateEntry = omitDeep(updateEntry, [
-    "__component",
-    "locale",
-    "localizations",
-    "createdAt",
-    "createdBy",
-    "updatedAt",
-    "updatedBy",
-    "publishedAt",
-  ]);
-  // set dynamic zone compoonent keys again
-  dynamicZoneComponentKeys.forEach((v) => {
-    set(updateEntry, v.key, v.component);
-  });
-
-  const filteredBaseEntry = omitDeep(baseEntry, [
-    // "__component", // do not omit the __component
-    "locale",
-    "localizations",
-    "createdAt",
-    "createdBy",
-    "updatedAt",
-    "updatedBy",
-    "publishedAt",
-  ]);
-  const filteredFullyPopulatedLocalizedEntry = omitDeep(fullyPopulatedLocalizedEntry, [
-    // "__component", // do not omit the __component
-    "locale",
-    "localizations",
-    "createdAt",
-    "createdBy",
-    "updatedAt",
-    "updatedBy",
-    "publishedAt",
-  ]);
-  const populatedEntry = await populateCreateUpdateEntryWithBaseEntry(
-    allModels,
-    updateEntry,
-    filteredBaseEntry,
-    filteredFullyPopulatedLocalizedEntry,
-    uid,
-    locale
-  );
-
-  // return updateEntry;
-  return populatedEntry;
-};
-
-module.exports = parsedLocalazyEntryToUpdateEntry;

package/server/utils/pick-deep.js

@@ -1,22 +0,0 @@
-"use strict";
-const isObject = require("lodash/isObject");
-const set = require("lodash/set");
-const includes = require("lodash/includes");
-
-const deepLodashPick = (obj, keys, newObj = {}, path = []) => {
-  for (let k in obj) {
-    const value = obj[k];
-
-    if (isObject(value)) {
-      path.push(k);
-      deepLodashPick(value, keys, newObj, path);
-      path.pop();
-    } else if (includes(keys, k)) {
-      set(newObj, [...path, k], value);
-    }
-  }
-
-  return newObj;
-}
-
-module.exports = deepLodashPick;

package/server/utils/pick-entries.js

@@ -1,37 +0,0 @@
-"use strict";
-
-const isDynamicZoneKey = (key) => {
-  const matches = key.match(/\[\d+;[\w-]+\./g);
-  return matches !== null;
-};
-
-const pickEntries = (flatten, pickPaths) => {
-  // * Dynamic zones properties must! always be in 1st level (not in component; Strapi restrictions)
-  const pickedEntries = {};
-  const mappedPickPaths = pickPaths.map((pickPath) =>
-    pickPath.replace(/\[\d+\]/g, "")
-  );
-
-  // filter out "__component"
-  const filteredFlatten = Object.fromEntries(
-    Object.entries(flatten).filter(([key]) => !key.includes("__component"))
-  );
-  Object.keys(filteredFlatten).forEach((key) => {
-    let filteredKey = key;
-    filteredKey = filteredKey.replace(/\[\d+\]/g, "");
-    if (isDynamicZoneKey(key)) {
-      filteredKey = filteredKey.replace(/\[\d+;[\w-]+\./g, `[`);
-    }
-    // if (mappedPickPaths.includes(filteredKey)) {
-      if (
-        mappedPickPaths.includes(filteredKey) ||
-        // include JSON fields
-        mappedPickPaths.some((pickPath) => filteredKey.startsWith(`${pickPath}.`))
-      ) {
-      pickedEntries[key] = flatten[key];
-    }
-  });
-  return pickedEntries;
-};
-
-module.exports = pickEntries;