@commercetools-frontend/experimental-components 0.0.2

package/src/utils/graphql/graphql.js

@@ -0,0 +1,579 @@
+import omit from 'lodash.omit';
+import pick from 'lodash.pick';
+import isEmpty from 'lodash.isempty';
+
+import {
+  applyTransformedLocalizedFields,
+  transformLocalizedStringToLocalizedField,
+} from '@commercetools-frontend/l10n';
+import { PRECISION_TYPES } from '../../internal-index';
+
+/**
+ * Checks if a value is a LocalizedString
+ *
+ * { en: 'Hello' } -> true
+ * 'Hello' -> false
+ */
+
+export const getIsLocalizedString = (maybeLocalizedString) => {
+  if (typeof maybeLocalizedString === 'string') return false;
+  if (
+    !maybeLocalizedString ||
+    (typeof maybeLocalizedString === 'object' &&
+      Object.keys(maybeLocalizedString).length === 0)
+  )
+    return false;
+
+  return true;
+};
+
+/**
+ * Transforms a list of `CustomField` into a `CustomField` object
+ *
+ * [{ name: 'fieldA', value: 'Hello' }] -> { fieldA: 'Hello' }
+ */
+export const transformCustomFieldsRawToCustomFields = (customFieldsRaw) => {
+  if (!customFieldsRaw || customFieldsRaw.length === 0) return null;
+  return customFieldsRaw.reduce(
+    (customFields, customField) => ({
+      ...customFields,
+      [customField.name]: customField.value,
+    }),
+    {}
+  );
+};
+
+// --- Types mapping ---
+
+/**
+ * Map category GraphQL shape with nameAllLocales to reference shape
+ * Includes ancestors and parent
+ *
+ * @param {Object} category - A category result object from graphql
+ * @return {Object} Category (as a REST API representation):
+ * `{ id, obj: { id, name } }`
+ */
+export function transformLocalizedFieldsForCategory(
+  category,
+  transformationOptions = [{ from: 'nameAllLocales', to: 'name' }]
+) {
+  const transformedData = applyTransformedLocalizedFields(
+    category,
+    transformationOptions
+  );
+  const parent = category.parent
+    ? transformLocalizedFieldsForCategory(category.parent)
+    : null;
+  const ancestors = category.ancestors
+    ? category.ancestors.map((ancestor) =>
+        transformLocalizedFieldsForCategory(ancestor)
+      )
+    : null;
+  return {
+    ...transformedData,
+    ...(parent ? { parent } : {}),
+    ...(ancestors ? { ancestors } : {}),
+  };
+}
+
+export function transformLocalizedFieldsForCartDiscount(cartDiscount) {
+  const transformationOptions = [{ from: 'nameAllLocales', to: 'name' }];
+  return applyTransformedLocalizedFields(cartDiscount, transformationOptions);
+}
+
+export function mapShippingRateTierToGraphQL(tiers) {
+  return tiers.reduce(
+    (graphQlTiers, tier) => [
+      ...graphQlTiers,
+      {
+        [tier.type]: {
+          price: tier.price
+            ? {
+                centAmount: tier.price.centAmount,
+                currencyCode: tier.price.currencyCode,
+              }
+            : undefined,
+          minimumCentAmount: tier.minimumCentAmount,
+          value: tier.value || undefined,
+          priceFunction: tier.priceFunction
+            ? {
+                function: tier.priceFunction.function,
+                currencyCode: tier.priceFunction.currencyCode,
+              }
+            : undefined,
+          score: tier.score,
+        },
+      },
+    ],
+    []
+  );
+}
+
+/**
+ * NOTE:
+ * This module massages update actions produced by the JS SDK
+ * to be compatible with CTP GraphQL mutations. This logic should be
+ * moved into the JS SDK once discounts is fully 100% migrated to
+ * GraphQL or any other plugin/app needs this functionality. Until
+ * then this serves as a collective set of requirements before
+ * prematurely adding a not fully working set of conversions to the
+ * JS SDK.
+ */
+
+export const createAttributeTypeValue = (attribute) => {
+  switch (attribute.type.name) {
+    case 'set':
+      return {
+        set: {
+          elementType: createAttributeTypeValue({
+            type: attribute.type.elementType,
+          }),
+        },
+      };
+    case 'boolean':
+    case 'date':
+    case 'datetime':
+    case 'ltext':
+    case 'money':
+    case 'number':
+    case 'text':
+    case 'time':
+      return {
+        [attribute.type.name]: {},
+      };
+    case 'enum':
+    case 'lenum':
+      return {
+        [attribute.type.name]: {
+          values: [],
+        },
+      };
+    case 'reference': {
+      return {
+        [attribute.type.name]: {
+          referenceTypeId: attribute.type.referenceTypeId,
+        },
+      };
+    }
+    default:
+      return attribute.type;
+  }
+};
+/**
+ * converts the `changeValue` action to GraphQL actions variable
+ * @param {Object} actionPayload
+ */
+export const convertChangeValueAction = (actionPayload) => {
+  const valueType = actionPayload.value.type;
+  const possibleTypeKeys = {
+    relative: ['permyriad'],
+    absolute: ['money'],
+    fixed: ['money'],
+    giftLineItem: [
+      'product',
+      'variantId',
+      'distributionChannel',
+      'supplyChannel',
+      'ResourceIdentifierInput',
+    ],
+  };
+  const filteredValue = pick(actionPayload.value, possibleTypeKeys[valueType]);
+  if (filteredValue.money)
+    filteredValue.money = filteredValue.money.map((valueItem) =>
+      omit(valueItem, '__typename')
+    );
+  return {
+    changeValue: {
+      value: {
+        [valueType]: filteredValue,
+      },
+    },
+  };
+};
+/**
+ * This function changes any payload after the actions have been computed.
+ * Currently we only need to change the `setCustomField` action payload
+ * as its dynamic content can not be typed in SDL for the mutation.
+ */
+const convertAction = (actionName, actionPayload) => {
+  const getNameFromPayload = (payload) => {
+    // changeName for `Organizations`
+    if (typeof payload.name === 'string') return payload;
+    // changeName for `UserProfile`
+    if (payload.firstName || payload.lastName) return payload;
+    // assume `changeName` for LocalizedString type
+    return {
+      name: transformLocalizedStringToLocalizedField(payload.name),
+    };
+  };
+
+  switch (actionName) {
+    case 'changeName':
+      return {
+        [actionName]: getNameFromPayload(actionPayload),
+      };
+    case 'setDescription':
+    case 'changeDescription':
+      return {
+        [actionName]: {
+          description: getIsLocalizedString(actionPayload.description)
+            ? transformLocalizedStringToLocalizedField(
+                actionPayload.description
+              )
+            : actionPayload.description,
+        },
+      };
+    case 'setLocalizedDescription':
+      return {
+        [actionName]: {
+          localizedDescription: transformLocalizedStringToLocalizedField(
+            actionPayload.localizedDescription
+          ),
+        },
+      };
+    case 'setName':
+      return {
+        [actionName]: {
+          name: Array.isArray(actionPayload.name)
+            ? actionPayload.name
+            : transformLocalizedStringToLocalizedField(actionPayload.name),
+        },
+      };
+    case 'setLineItemCustomField':
+    case 'setCustomLineItemCustomField':
+      return {
+        [actionName]: {
+          lineItemId: actionPayload.lineItemId,
+          name: actionPayload.name,
+          value: JSON.stringify(actionPayload.value),
+        },
+      };
+    case 'setCustomField':
+      return {
+        [actionName]: {
+          name: actionPayload.name,
+          value: JSON.stringify(actionPayload.value),
+        },
+      };
+    case 'setCustomType':
+      return {
+        [actionName]: {
+          typeId: actionPayload.type?.id,
+          fields: actionPayload.fields
+            ? Object.entries(actionPayload.fields).map(
+                ([customField, value]) => ({
+                  name: customField,
+                  value: JSON.stringify(value),
+                })
+              )
+            : undefined,
+        },
+      };
+    case 'removeLocation':
+      return {
+        [actionName]: {
+          location: {
+            country: actionPayload.location.country,
+          },
+        },
+      };
+    case 'addLocation':
+      return {
+        [actionName]: {
+          location: {
+            country: actionPayload.location.country,
+          },
+        },
+      };
+    case 'changeLabel':
+      return {
+        changeLabel: {
+          attributeName: actionPayload.attributeName,
+          label: transformLocalizedStringToLocalizedField(actionPayload.label),
+        },
+      };
+    case 'setInputTip':
+      return {
+        setInputTip: {
+          attributeName: actionPayload.attributeName,
+          inputTip: transformLocalizedStringToLocalizedField(
+            actionPayload.inputTip
+          ),
+        },
+      };
+    case 'addAttributeDefinition':
+      return {
+        [actionName]: {
+          attributeDefinition: {
+            ...actionPayload.attribute,
+            label: transformLocalizedStringToLocalizedField(
+              actionPayload.attribute.label
+            ),
+            inputTip: transformLocalizedStringToLocalizedField(
+              actionPayload.attribute.inputTip
+            ),
+            type: createAttributeTypeValue(actionPayload.attribute),
+          },
+        },
+      };
+    case 'replaceTaxRate':
+      return {
+        [actionName]: {
+          taxRate: {
+            name: actionPayload.taxRate.name,
+            country: actionPayload.taxRate.country,
+            includedInPrice: actionPayload.taxRate.includedInPrice,
+            amount: actionPayload.taxRate.amount,
+            state: actionPayload.taxRate.state,
+            subRates: actionPayload.taxRate.subRates,
+          },
+          taxRateId: actionPayload.taxRateId,
+        },
+      };
+    case 'addZone':
+      return {
+        [actionName]: {
+          zone: {
+            id: actionPayload.zone.id,
+            typeId: actionPayload.zone.typeId,
+          },
+        },
+      };
+    case 'removeZone':
+      return {
+        [actionName]: {
+          zone: {
+            id: actionPayload.zone.id,
+            typeId: actionPayload.zone.typeId,
+          },
+        },
+      };
+    case 'changeTaxCategory':
+      return {
+        [actionName]: {
+          taxCategory: {
+            id: actionPayload.taxCategory.id,
+            typeId: actionPayload.taxCategory.typeId,
+          },
+        },
+      };
+    case 'addShippingRate':
+      return {
+        [actionName]: {
+          zone: {
+            id: actionPayload.zone.id,
+            typeId: actionPayload.zone.typeId,
+          },
+          shippingRate: {
+            price: {
+              centAmount: actionPayload.shippingRate.price.centAmount,
+              currencyCode: actionPayload.shippingRate.price.currencyCode,
+            },
+            freeAbove: actionPayload.shippingRate.freeAbove
+              ? {
+                  centAmount: actionPayload.shippingRate.freeAbove.centAmount,
+                  currencyCode:
+                    actionPayload.shippingRate.freeAbove.currencyCode,
+                }
+              : undefined,
+            tiers: actionPayload.shippingRate.tiers
+              ? mapShippingRateTierToGraphQL(actionPayload.shippingRate.tiers)
+              : undefined,
+          },
+        },
+      };
+    case 'removeShippingRate':
+      return {
+        [actionName]: {
+          zone: {
+            id: actionPayload.zone.id,
+            typeId: actionPayload.zone.typeId,
+          },
+          shippingRate: {
+            price: {
+              centAmount: actionPayload.shippingRate.price.centAmount,
+              currencyCode: actionPayload.shippingRate.price.currencyCode,
+            },
+            freeAbove: actionPayload.shippingRate.freeAbove
+              ? {
+                  centAmount: actionPayload.shippingRate.freeAbove.centAmount,
+                  currencyCode:
+                    actionPayload.shippingRate.freeAbove.currencyCode,
+                }
+              : undefined,
+            tiers: actionPayload.shippingRate.tiers
+              ? mapShippingRateTierToGraphQL(actionPayload.shippingRate.tiers)
+              : undefined,
+          },
+        },
+      };
+    case 'changeValue':
+      return convertChangeValueAction(actionPayload);
+    // product-types -> attributes -> enum
+    case 'addLocalizedEnumValue':
+      return {
+        [actionName]: {
+          attributeName: actionPayload.attributeName,
+          value: {
+            ...actionPayload.value,
+            label: transformLocalizedStringToLocalizedField(
+              actionPayload.value.label
+            ),
+          },
+        },
+      };
+    case 'changeLocalizedEnumValueLabel':
+      return {
+        [actionName]: {
+          attributeName: actionPayload.attributeName,
+          newValue: {
+            ...actionPayload.newValue,
+            label: transformLocalizedStringToLocalizedField(
+              actionPayload.newValue.label
+            ),
+          },
+        },
+      };
+    case 'setShippingRateInputType':
+      return {
+        [actionName]: {
+          shippingRateInputType: actionPayload.shippingRateInputType?.type
+            ? {
+                [actionPayload.shippingRateInputType.type]: {
+                  values:
+                    actionPayload.shippingRateInputType.type ===
+                    'CartClassification'
+                      ? actionPayload.shippingRateInputType.values.map(
+                          (value) => ({
+                            key: value.key,
+                            label: value.allLocaleLabels,
+                          })
+                        )
+                      : undefined,
+                },
+              }
+            : undefined,
+        },
+      };
+    case 'addCustomLineItem': {
+      return {
+        [actionName]: {
+          slug: actionPayload.slug,
+          quantity: actionPayload.quantity,
+          name: transformLocalizedStringToLocalizedField(actionPayload.name),
+          taxCategory: actionPayload.taxCategory,
+          money: {
+            [actionPayload.money.type]: {
+              centAmount: actionPayload.money.centAmount,
+              currencyCode: actionPayload.money.currencyCode,
+              ...(actionPayload.money.type ===
+                PRECISION_TYPES.highPrecision && {
+                preciseAmount: actionPayload.money.preciseAmount,
+                fractionDigits: actionPayload.money.fractionDigits,
+              }),
+            },
+          },
+        },
+      };
+    }
+    case 'setDataFences':
+      return {
+        [actionName]: {
+          dataFences: actionPayload.dataFences.reduce(
+            (nextDataFences, dataFence) => {
+              if (dataFence.type.toLowerCase() === 'store')
+                return [
+                  ...nextDataFences,
+                  {
+                    [dataFence.type.toLowerCase()]: {
+                      storeKeys: dataFence.storeKeys,
+                    },
+                  },
+                ];
+              return nextDataFences;
+            },
+            []
+          ),
+        },
+      };
+    case 'changeTarget':
+      return {
+        [actionName]: {
+          target: {
+            [actionPayload.target.type]: omit(actionPayload.target, [
+              'type',
+              '__typename',
+            ]),
+          },
+        },
+      };
+    case 'addAddress':
+    case 'changeAddress': {
+      const { fields = {} } = actionPayload.address?.custom || {};
+      const customFields = isEmpty(fields)
+        ? null
+        : Object.entries(fields).map(([name, value]) => ({
+            name,
+            value: JSON.stringify(value),
+          }));
+      const custom = actionPayload.address?.custom?.type?.id
+        ? {
+            type: {
+              id: actionPayload.address.custom.type.id,
+            },
+            fields: customFields,
+          }
+        : null;
+      return {
+        [actionName]: {
+          ...actionPayload,
+          address: {
+            ...omit(actionPayload.address, ['__typename']),
+            custom,
+          },
+        },
+      };
+    }
+    case 'setAddressCustomType': {
+      const { addressId, fields = {}, type } = actionPayload || {};
+      const customFields = isEmpty(fields)
+        ? null
+        : Object.entries(fields).map(([name, value]) => ({
+            name,
+            value: JSON.stringify(value),
+          }));
+      const customType = type?.id ? { id: type.id } : null;
+
+      return {
+        [actionName]: {
+          addressId,
+          fields: customFields,
+          type: customType,
+        },
+      };
+    }
+    default:
+      return { [actionName]: actionPayload };
+  }
+};
+
+export const createGraphQlUpdateActions = (actions) =>
+  actions.reduce(
+    (previousActions, { action: actionName, ...actionPayload }) => [
+      ...previousActions,
+      convertAction(actionName, actionPayload),
+    ],
+    []
+  );
+
+export const extractErrorFromGraphQlResponse = (graphQlResponse) => {
+  if (graphQlResponse.networkError?.result?.errors?.length > 0) {
+    return graphQlResponse.networkError.result.errors;
+  }
+
+  if (graphQlResponse.graphQLErrors?.length > 0) {
+    return graphQlResponse.graphQLErrors;
+  }
+
+  return graphQlResponse;
+};