@commercetools-frontend/experimental-components 0.0.2

package/src/features/platform-limits/shared/hooks/use-platform-limits-fetcher/__mocks__/index.js

@@ -0,0 +1,405 @@
+import {
+  PlatformLimits,
+  LimitWithCurrent,
+  PlatformLimitsShippingMethods,
+  PlatformLimitsTaxCategories,
+  PlatformLimitsCustomers,
+  PlatformLimitsZones,
+  PlatformLimitsCustomerGroups,
+  PlatformLimitsStores,
+} from '@commercetools-local/test-data';
+
+export const shippingMethodsWithNonExceeded = PlatformLimits.random()
+  .shippingMethods(
+    PlatformLimitsShippingMethods.random().total(
+      LimitWithCurrent.presets.withNonExceeded()
+    )
+  )
+  .buildGraphql();
+export const shippingMethodsWithWarningExceeded = PlatformLimits.random()
+  .shippingMethods(
+    PlatformLimitsShippingMethods.random().total(
+      LimitWithCurrent.presets.withWarningExceeded()
+    )
+  )
+  .buildGraphql();
+export const shippingMethodsWithExceeded = PlatformLimits.random()
+  .shippingMethods(
+    PlatformLimitsShippingMethods.random().total(
+      LimitWithCurrent.presets.withExceeded()
+    )
+  )
+  .buildGraphql();
+export const shippingMethodswithUndefined = PlatformLimits.random()
+  .shippingMethods(
+    PlatformLimitsShippingMethods.random().total(
+      LimitWithCurrent.presets.withUndefined()
+    )
+  )
+  .buildGraphql();
+
+export const taxCategoriesWithNonExceeded = PlatformLimits.random()
+  .taxCategories(
+    PlatformLimitsTaxCategories.random().total(
+      LimitWithCurrent.presets.withNonExceeded()
+    )
+  )
+  .buildGraphql();
+
+export const taxCategoriesWithWarningExceeded = PlatformLimits.random()
+  .taxCategories(
+    PlatformLimitsTaxCategories.random().total(
+      LimitWithCurrent.presets.withWarningExceeded()
+    )
+  )
+  .buildGraphql();
+
+export const taxCategoriesWithExceeded = PlatformLimits.random()
+  .taxCategories(
+    PlatformLimitsTaxCategories.random().total(
+      LimitWithCurrent.presets.withExceeded()
+    )
+  )
+  .buildGraphql();
+
+export const taxCategoriesWithUndefined = PlatformLimits.random()
+  .taxCategories(
+    PlatformLimitsTaxCategories.random().total(
+      LimitWithCurrent.presets.withUndefined()
+    )
+  )
+  .buildGraphql();
+
+export const customersWithNonExceeded = PlatformLimits.random()
+  .customers(
+    PlatformLimitsCustomers.random().total(
+      LimitWithCurrent.presets.withNonExceeded()
+    )
+  )
+  .buildGraphql();
+export const customersWithWarningExceeded = PlatformLimits.random()
+  .customers(
+    PlatformLimitsCustomers.random().total(
+      LimitWithCurrent.presets.withWarningExceeded()
+    )
+  )
+  .buildGraphql();
+
+export const customersWithExceeded = PlatformLimits.random()
+  .customers(
+    PlatformLimitsCustomers.random().total(
+      LimitWithCurrent.presets.withExceeded()
+    )
+  )
+  .buildGraphql();
+
+export const customerGroupsWithNonExceeded = PlatformLimits.random()
+  .customerGroups(
+    PlatformLimitsCustomerGroups.random().total(
+      LimitWithCurrent.presets.withNonExceeded()
+    )
+  )
+  .buildGraphql();
+export const customerGroupsWithWarningExceeded = PlatformLimits.random()
+  .customerGroups(
+    PlatformLimitsCustomerGroups.random().total(
+      LimitWithCurrent.presets.withWarningExceeded()
+    )
+  )
+  .buildGraphql();
+
+export const customerGroupsWithExceeded = PlatformLimits.random()
+  .customerGroups(
+    PlatformLimitsCustomerGroups.random().total(
+      LimitWithCurrent.presets.withExceeded()
+    )
+  )
+  .buildGraphql();
+
+export const zonesWithNonExceeded = PlatformLimits.random()
+  .zones(
+    PlatformLimitsZones.random().total(
+      LimitWithCurrent.presets.withNonExceeded()
+    )
+  )
+  .buildGraphql();
+export const zonesWithWarningExceeded = PlatformLimits.random()
+  .zones(
+    PlatformLimitsZones.random().total(
+      LimitWithCurrent.presets.withWarningExceeded()
+    )
+  )
+  .buildGraphql();
+export const zonesWithExceeded = PlatformLimits.random()
+  .zones(
+    PlatformLimitsZones.random().total(LimitWithCurrent.presets.withExceeded())
+  )
+  .buildGraphql();
+export const zoneswithUndefined = PlatformLimits.random()
+  .zones(
+    PlatformLimitsZones.random().total(LimitWithCurrent.presets.withUndefined())
+  )
+  .buildGraphql();
+export const storesWithNonExceeded = PlatformLimits.random()
+  .stores(
+    PlatformLimitsStores.random()
+      .total(LimitWithCurrent.presets.withNonExceeded())
+      .inventorySupplyChannels(LimitWithCurrent.presets.withNonExceeded())
+      .productDistributionChannels(LimitWithCurrent.presets.withNonExceeded())
+  )
+  .buildGraphql();
+export const storesWithExceeded = PlatformLimits.random()
+  .stores(
+    PlatformLimitsStores.random()
+      .total(LimitWithCurrent.presets.withExceeded())
+      .inventorySupplyChannels(LimitWithCurrent.presets.withExceeded())
+      .productDistributionChannels(LimitWithCurrent.presets.withExceeded())
+  )
+  .buildGraphql();
+export const storesWithWarningExceeded = PlatformLimits.random()
+  .stores(
+    PlatformLimitsStores.random()
+      .total(LimitWithCurrent.presets.withWarningExceeded())
+      .inventorySupplyChannels(LimitWithCurrent.presets.withWarningExceeded())
+      .productDistributionChannels(
+        LimitWithCurrent.presets.withWarningExceeded()
+      )
+  )
+  .buildGraphql();
+
+const mockNames = {
+  withShippingMethodsWithNonExceeded: 'withShippingMethodsWithNonExceeded',
+  withShippingMethodsWithWarningExceeded:
+    'withShippingMethodsWithWarningExceeded',
+  withShippingMethodsWithExceeded: 'withShippingMethodsWithExceeded',
+  withShippingMethodssUndefined: 'withShippingMethodssUndefined',
+  withTaxCategoriesWithNonExceeded: 'withTaxCategoriesWithNonExeeded',
+  withTaxCategoriesWithWarningExceeded: 'withTaxCategoriesWithWarningExceeded',
+  withTaxCategoriesWithExceeded: 'withTaxCategoriesWithExceeded',
+  withTaxCategoriesUndefined: 'withTaxCategoriesUndefined',
+  withCustomersWithNonExceeded: 'withCustomersWithNonExceeded',
+  withCustomersWithWarningExceeded: 'withCustomersWithWarningExceeded',
+  withCustomersWithExceeded: 'withCustomersWithExceeded',
+  withCustomerGroupsWithNonExceeded: 'withCustomerGroupsWithNonExceeded',
+  withCustomerGroupsWithWarningExceeded:
+    'withCustomerGroupsWithWarningExceeded',
+  withCustomerGroupsWithExceeded: 'withCustomerGroupsWithExceeded',
+  withZonesWithNonExceeded: 'withZonesWithNonExceeded',
+  withZonesWithWarningExceeded: 'withZonesWithWarningExceeded',
+  withZonesWithExceeded: 'withZonesWithExceeded',
+  withZonesUndefined: 'withZonesUndefined',
+  withStoresWithNonExceeded: 'withStoresWithNonExceeded',
+  withStoresWithExceeded: 'withStoresWithExceeded',
+  withStoresWithWarningExceeded: 'withStoresWithWarningExceeded',
+};
+const mocks = {
+  [mockNames.withShippingMethodsWithNonExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: shippingMethodsWithNonExceeded,
+  },
+  [mockNames.withShippingMethodsWithWarningExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: shippingMethodsWithWarningExceeded,
+  },
+  [mockNames.withShippingMethodsWithExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: shippingMethodsWithExceeded,
+  },
+  [mockNames.withShippingMethodsUndefined]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: shippingMethodswithUndefined,
+  },
+  [mockNames.withTaxCategoriesWithNonExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: taxCategoriesWithNonExceeded,
+  },
+  [mockNames.withTaxCategoriesWithWarningExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: taxCategoriesWithWarningExceeded,
+  },
+  [mockNames.withTaxCategoriesWithExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: taxCategoriesWithExceeded,
+  },
+  [mockNames.withTaxCategoriesUndefined]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: taxCategoriesWithUndefined,
+  },
+  [mockNames.withCustomersWithNonExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: customersWithNonExceeded,
+  },
+  [mockNames.withCustomersWithWarningExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: customersWithWarningExceeded,
+  },
+  [mockNames.withCustomersWithExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: customersWithExceeded,
+  },
+  [mockNames.withCustomerGroupsWithNonExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: customerGroupsWithNonExceeded,
+  },
+  [mockNames.withCustomerGroupsWithWarningExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: customerGroupsWithWarningExceeded,
+  },
+  [mockNames.withCustomerGroupsWithExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: customerGroupsWithExceeded,
+  },
+  [mockNames.withZonesWithNonExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: zonesWithNonExceeded,
+  },
+  [mockNames.withZonesWithWarningExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: zonesWithWarningExceeded,
+  },
+  [mockNames.withZonesWithExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: zonesWithExceeded,
+  },
+  [mockNames.withZonesUndefined]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: zoneswithUndefined,
+  },
+  [mockNames.withStoresWithNonExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: storesWithNonExceeded,
+  },
+  [mockNames.withStoresWithExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: storesWithExceeded,
+  },
+  [mockNames.withStoresWithWarningExceeded]: {
+    isLoading: false,
+    error: null,
+    refetch: jest.fn(),
+    platformLimits: storesWithWarningExceeded,
+  },
+};
+
+let mockName;
+
+const usePlatformLimitsFetcher = () => mocks[mockName];
+
+// shipping methods
+usePlatformLimitsFetcher.withShippingMethodsWithNonExceeded = () => {
+  mockName = mockNames.withShippingMethodsWithNonExceeded;
+};
+usePlatformLimitsFetcher.withShippingMethodsWithWarningExceeded = () => {
+  mockName = mockNames.withShippingMethodsWithWarningExceeded;
+};
+usePlatformLimitsFetcher.withShippingMethodsWithExceeded = () => {
+  mockName = mockNames.withShippingMethodsWithExceeded;
+};
+usePlatformLimitsFetcher.withShippingMethodsUndefined = () => {
+  mockName = mockNames.withShippingMethodsUndefined;
+};
+
+// tax categories
+usePlatformLimitsFetcher.withTaxCategoriesWithNonExceeded = () => {
+  mockName = mockNames.withTaxCategoriesWithNonExceeded;
+};
+usePlatformLimitsFetcher.withTaxCategoriesWithWarningExceeded = () => {
+  mockName = mockNames.withTaxCategoriesWithWarningExceeded;
+};
+usePlatformLimitsFetcher.withTaxCategoriesWithExceeded = () => {
+  mockName = mockNames.withTaxCategoriesWithExceeded;
+};
+usePlatformLimitsFetcher.withTaxCategoriesUndefined = () => {
+  mockName = mockNames.withTaxCategoriesUndefined;
+};
+
+// customers
+usePlatformLimitsFetcher.withCustomersWithNonExceeded = () => {
+  mockName = mockNames.withCustomersWithNonExceeded;
+};
+usePlatformLimitsFetcher.withCustomersWithWarningExceeded = () => {
+  mockName = mockNames.withCustomersWithWarningExceeded;
+};
+usePlatformLimitsFetcher.withCustomersWithExceeded = () => {
+  mockName = mockNames.withCustomersWithExceeded;
+};
+
+// customer groups
+usePlatformLimitsFetcher.withCustomerGroupsWithNonExceeded = () => {
+  mockName = mockNames.withCustomerGroupsWithNonExceeded;
+};
+usePlatformLimitsFetcher.withCustomerGroupsWithWarningExceeded = () => {
+  mockName = mockNames.withCustomerGroupsWithWarningExceeded;
+};
+usePlatformLimitsFetcher.withCustomerGroupsWithExceeded = () => {
+  mockName = mockNames.withCustomerGroupsWithExceeded;
+};
+
+// zones
+usePlatformLimitsFetcher.withZonesWithNonExceeded = () => {
+  mockName = mockNames.withZonesWithNonExceeded;
+};
+usePlatformLimitsFetcher.withZonesWithWarningExceeded = () => {
+  mockName = mockNames.withZonesWithWarningExceeded;
+};
+usePlatformLimitsFetcher.withZonesWithExceeded = () => {
+  mockName = mockNames.withZonesWithExceeded;
+};
+usePlatformLimitsFetcher.withZonesUndefined = () => {
+  mockName = mockNames.withZonesUndefined;
+};
+
+// stores
+usePlatformLimitsFetcher.withStoresWithNonExceeded = () => {
+  mockName = mockNames.withStoresWithNonExceeded;
+};
+
+usePlatformLimitsFetcher.withStoresWithExceeded = () => {
+  mockName = mockNames.withStoresWithExceeded;
+};
+
+usePlatformLimitsFetcher.withStoresWithWarningExceeded = () => {
+  mockName = mockNames.withStoresWithWarningExceeded;
+};
+
+export default usePlatformLimitsFetcher;

package/src/features/platform-limits/shared/hooks/use-platform-limits-fetcher/index.js

@@ -0,0 +1 @@
+export { default } from './use-platform-limits-fetcher';

package/src/features/platform-limits/shared/hooks/use-platform-limits-fetcher/mocks/handlers.js

@@ -0,0 +1,16 @@
+import { graphql } from 'msw';
+
+const handlers = {
+  PlatformLimits: {
+    all: (platformLimiits) =>
+      graphql.query('PlatformLimitsFetcherQuery', (req, res, ctx) =>
+        res(
+          ctx.data({
+            limits: platformLimiits,
+          })
+        )
+      ),
+  },
+};
+
+export default handlers;

package/src/features/platform-limits/shared/hooks/use-platform-limits-fetcher/mocks/index.js

@@ -0,0 +1,4 @@
+/* eslint-disable import/prefer-default-export */
+import handlers from './handlers';
+
+export { handlers };

package/src/features/platform-limits/shared/hooks/use-platform-limits-fetcher/platform-limits-query-variables.js

@@ -0,0 +1,18 @@
+import camelCase from 'lodash.camelcase';
+
+import { RESOURCES_WITH_PLATFORM_LIMITS } from '../../constants';
+
+const resourcesWithPlatformLimits = Object.keys(RESOURCES_WITH_PLATFORM_LIMITS);
+
+const createQueryVariables = (platformLimit) =>
+  resourcesWithPlatformLimits.reduce(
+    (previousIncludedLimits, nextNameOfLimit) => ({
+      [camelCase(`should include ${nextNameOfLimit}`)]: platformLimit
+        ? nextNameOfLimit === platformLimit
+        : true,
+      ...previousIncludedLimits,
+    }),
+    {}
+  );
+
+export default createQueryVariables;

package/src/features/platform-limits/shared/hooks/use-platform-limits-fetcher/use-platform-limits-fetcher.ctp.graphql

@@ -0,0 +1,87 @@
+query PlatformLimitsFetcherQuery(
+  $shouldIncludeShoppingLists: Boolean!
+  $shouldIncludeProductDiscounts: Boolean!
+  $shouldIncludeCartDiscounts: Boolean!
+  $shouldIncludeStores: Boolean!
+  $shouldIncludeCustomers: Boolean!
+  $shouldIncludeCustomerGroups: Boolean!
+  $shouldIncludeZones: Boolean!
+  $shouldIncludeTaxCategories: Boolean!
+  $shouldIncludeShippingMethods: Boolean!
+  $shouldIncludeCarts: Boolean!
+) {
+  limits {
+    shoppingLists @include(if: $shouldIncludeShoppingLists) {
+      total {
+        limit
+        current
+      }
+      lineItems {
+        limit
+      }
+      textLineItems {
+        limit
+      }
+    }
+    productDiscounts @include(if: $shouldIncludeProductDiscounts) {
+      totalActive {
+        limit
+        current
+      }
+    }
+    cartDiscounts @include(if: $shouldIncludeCartDiscounts) {
+      totalActiveWithoutDiscountCodes {
+        limit
+        current
+      }
+    }
+    stores @include(if: $shouldIncludeStores) {
+      total {
+        limit
+        current
+      }
+      inventorySupplyChannels {
+        limit
+      }
+      productDistributionChannels {
+        limit
+      }
+    }
+    customers @include(if: $shouldIncludeCustomers) {
+      total {
+        limit
+        current
+      }
+    }
+    customerGroups @include(if: $shouldIncludeCustomerGroups) {
+      total {
+        limit
+        current
+      }
+    }
+    zones @include(if: $shouldIncludeZones) {
+      total {
+        limit
+        current
+      }
+    }
+    taxCategories @include(if: $shouldIncludeTaxCategories) {
+      total {
+        limit
+        current
+      }
+    }
+    shippingMethods @include(if: $shouldIncludeShippingMethods) {
+      total {
+        limit
+        current
+      }
+    }
+    carts @include(if: $shouldIncludeCarts) {
+      total {
+        limit
+        current
+      }
+    }
+  }
+}

package/src/features/platform-limits/shared/hooks/use-platform-limits-fetcher/use-platform-limits-fetcher.js

@@ -0,0 +1,30 @@
+import { useQuery } from '@apollo/client/react';
+import omit from 'lodash.omit';
+import { reportErrorToSentry } from '@commercetools-frontend/sentry';
+import { GRAPHQL_TARGETS } from '@commercetools-frontend/constants';
+import { PlatformLimitsFetcherQuery } from './use-platform-limits-fetcher.ctp.graphql';
+import createPlatformLimitsQueryVariables from './platform-limits-query-variables';
+
+const usePlatformLimitsFetcher = (platformLimit) => {
+  const { loading, error, data, refetch } = useQuery(
+    PlatformLimitsFetcherQuery,
+    {
+      variables: createPlatformLimitsQueryVariables(platformLimit),
+      context: {
+        target: GRAPHQL_TARGETS.COMMERCETOOLS_PLATFORM,
+      },
+      onError: reportErrorToSentry,
+    }
+  );
+
+  const platformLimits = !loading ? omit(data?.limits, '__typename') : {};
+
+  return {
+    isLoading: loading,
+    error,
+    platformLimits,
+    refetch,
+  };
+};
+
+export default usePlatformLimitsFetcher;