@commercetools-frontend/experimental-components 0.0.2 → 0.0.3

package/src/utils/graphql/graphql.js

@@ -1,579 +0,0 @@
-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;
-};