@jetshop/core 5.13.10-0 → 5.14.0-alpha.49df897e

package/boot/server/PersistedApolloClient.test.js

@@ -1,233 +1,233 @@
-// TODO
-// File reverted from TypeScript, should be reverted when pipeline supports it
-// https://gitlab.jetshop.se/jetshop/flight/merge_requests/409/diffs?commit_id=d30490f833ec2d2eec94e5a75ed99de71e666377
-// https://gitlab.jetshop.se/jetshop/flight/blob/94b6108017f6205e7d31f6bedb19c14f278d227a/packages/core/boot/server/PersistedApolloClient.test.ts
-
-import ApolloClient, { ApolloError } from 'apollo-client';
-import { PersistedApolloClient } from './PersistedApolloClient';
-import nock from 'nock';
-import { HttpLink } from 'apollo-link-http';
-import { InMemoryCache } from 'apollo-cache-inmemory';
-import channelsQuery from '../ChannelsQuery.gql';
-
-global.__IN_SERVER__ = true;
-jest.useFakeTimers();
-beforeEach(() => {
-  nock.disableNetConnect();
-});
-afterEach(() => {
-  jest.restoreAllMocks();
-  jest.clearAllTimers();
-  nock.enableNetConnect();
-  nock.cleanAll();
-});
-const apolloConfig = {
-  shopid: '...',
-  graphQLURI: 'http://localhost/graphql',
-  token: '...',
-  enableGateway: false,
-  channelsQuery
-};
-function getPendingResponse(persitedClient) {
-  const channelsIntervalQuery = persitedClient.channelsIntervalQuery;
-  return channelsIntervalQuery.getPendingResponse();
-}
-/**
- * Mocks response for `/graphql`
- * Only for **one** request, it resets on each call.
- */
-function mockResponse({ channels = null, statusCode = 200, errors }) {
-  const data = {
-    errors,
-    data: {
-      channels: Array.isArray(channels)
-        ? channels.map(channel =>
-            Object.assign(
-              {
-                __typename: 'Channel',
-                requiresAuth: false,
-                countries: null,
-                currencies: null,
-                defaultCurrency: null,
-                defaultLanguage: null,
-                displayName: null,
-                groupName: null,
-                isDefault: null,
-                languages: null,
-                settings: null,
-                name: null,
-                url: null,
-                imageUrl: null
-              },
-              channel
-            )
-          )
-        : null
-    }
-  };
-  const res = jest.fn(() => data);
-  nock('http://localhost')
-    .post('/graphql')
-    .reply(statusCode, res);
-  return res;
-}
-test('does request on init', async () => {
-  const firstCall = mockResponse({
-    channels: [
-      {
-        id: 1,
-        name: 'test'
-      }
-    ]
-  });
-  const persistedClient = new PersistedApolloClient({
-    createClientOpts: { apolloConfig }
-  });
-  await getPendingResponse(persistedClient);
-  expect(firstCall).toHaveBeenCalled();
-  const channels = await persistedClient.getChannels();
-  expect(channels).toHaveLength(1);
-  expect(channels[0].id).toBe(1);
-});
-test('does request on intervals', async () => {
-  mockResponse({
-    channels: [
-      {
-        id: 1,
-        name: 'test1'
-      }
-    ]
-  });
-  const channelsPollInterval = 60e3;
-  const persistedClient = new PersistedApolloClient({
-    createClientOpts: { apolloConfig },
-    channelsPollInterval
-  });
-  {
-    const channels = await persistedClient.getChannels();
-    expect(channels[0].name).toBe('test1');
-  }
-  {
-    mockResponse({
-      channels: [
-        {
-          id: 2,
-          name: 'test2'
-        }
-      ]
-    });
-    jest.advanceTimersByTime(channelsPollInterval + 1);
-    await getPendingResponse(persistedClient);
-    const channels = await persistedClient.getChannels();
-    expect(channels[0].name).toBe('test2');
-  }
-  {
-    mockResponse({
-      channels: [
-        {
-          id: 3,
-          name: 'test3'
-        }
-      ]
-    });
-    jest.advanceTimersByTime(channelsPollInterval);
-    await getPendingResponse(persistedClient);
-    const channels = await persistedClient.getChannels();
-    expect(channels[0].name).toBe('test3');
-  }
-});
-test('propagates bad statusCodes', async () => {
-  mockResponse({ statusCode: 500 });
-  const persistedClient = new PersistedApolloClient({
-    createClientOpts: { apolloConfig }
-  });
-  expect.assertions(1);
-  try {
-    await getPendingResponse(persistedClient);
-  } catch (err) {
-    expect(err.networkError.statusCode).toBe(500);
-  }
-});
-test('propagates when response contains GraphQL-errors', async () => {
-  const errorMessage = 'Something went wrong';
-  mockResponse({
-    errors: [
-      {
-        message: errorMessage,
-        locations: null
-      }
-    ]
-  });
-  const persistedClient = new PersistedApolloClient({
-    createClientOpts: { apolloConfig }
-  });
-  expect.assertions(2);
-  try {
-    await getPendingResponse(persistedClient);
-  } catch (_err) {
-    const err = _err;
-    expect(err).toBeInstanceOf(ApolloError);
-    expect(err.message).toBe(`GraphQL error: ${errorMessage}`);
-  }
-});
-test('extracting and using cache in new client', async () => {
-  mockResponse({
-    channels: [
-      {
-        id: 1,
-        name: 'test1'
-      }
-    ]
-  });
-  const pollInterval = 60e3;
-  const channelsPollInterval = 60e3;
-  const persistedClient = new PersistedApolloClient({
-    createClientOpts: { apolloConfig },
-    channelsPollInterval
-  });
-  await getPendingResponse(persistedClient);
-  {
-    const cache = persistedClient.extractCache();
-    expect(cache).toHaveProperty('Channel:1');
-    expect(cache['Channel:1'].name).toBe('test1');
-    const newClient = new ApolloClient({
-      link: new HttpLink(),
-      cache: new InMemoryCache().restore(cache)
-    });
-    const res = newClient.readQuery({
-      query: channelsQuery
-    });
-    expect(res.channels).toHaveLength(1);
-    expect(res.channels[0].name).toBe('test1');
-  }
-  // update data in new request
-  {
-    const mock = mockResponse({
-      channels: [
-        {
-          id: 1,
-          name: 'test1--updated'
-        },
-        {
-          id: 2,
-          name: 'test2'
-        }
-      ]
-    });
-    jest.advanceTimersByTime(pollInterval);
-    await getPendingResponse(persistedClient);
-    expect(mock).toHaveBeenCalled();
-    const cache = persistedClient.extractCache();
-    const newClient = new ApolloClient({
-      link: new HttpLink(),
-      cache: new InMemoryCache().restore(cache)
-    });
-    const res = newClient.readQuery({
-      query: channelsQuery
-    });
-    expect(res.channels).toHaveLength(2);
-    expect(res.channels[0].name).toBe('test1--updated');
-    expect(res.channels[1].name).toBe('test2');
-  }
-});
-//# sourceMappingURL=PersistedApolloClient.test.js.map
+// TODO
+// File reverted from TypeScript, should be reverted when pipeline supports it
+// https://gitlab.jetshop.se/jetshop/flight/merge_requests/409/diffs?commit_id=d30490f833ec2d2eec94e5a75ed99de71e666377
+// https://gitlab.jetshop.se/jetshop/flight/blob/94b6108017f6205e7d31f6bedb19c14f278d227a/packages/core/boot/server/PersistedApolloClient.test.ts
+
+import ApolloClient, { ApolloError } from 'apollo-client';
+import { PersistedApolloClient } from './PersistedApolloClient';
+import nock from 'nock';
+import { HttpLink } from 'apollo-link-http';
+import { InMemoryCache } from 'apollo-cache-inmemory';
+import channelsQuery from '../ChannelsQuery.gql';
+
+global.__IN_SERVER__ = true;
+jest.useFakeTimers();
+beforeEach(() => {
+  nock.disableNetConnect();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+  jest.clearAllTimers();
+  nock.enableNetConnect();
+  nock.cleanAll();
+});
+const apolloConfig = {
+  shopid: '...',
+  graphQLURI: 'http://localhost/graphql',
+  token: '...',
+  enableGateway: false,
+  channelsQuery
+};
+function getPendingResponse(persitedClient) {
+  const channelsIntervalQuery = persitedClient.channelsIntervalQuery;
+  return channelsIntervalQuery.getPendingResponse();
+}
+/**
+ * Mocks response for `/graphql`
+ * Only for **one** request, it resets on each call.
+ */
+function mockResponse({ channels = null, statusCode = 200, errors }) {
+  const data = {
+    errors,
+    data: {
+      channels: Array.isArray(channels)
+        ? channels.map(channel =>
+            Object.assign(
+              {
+                __typename: 'Channel',
+                requiresAuth: false,
+                countries: null,
+                currencies: null,
+                defaultCurrency: null,
+                defaultLanguage: null,
+                displayName: null,
+                groupName: null,
+                isDefault: null,
+                languages: null,
+                settings: null,
+                name: null,
+                url: null,
+                imageUrl: null
+              },
+              channel
+            )
+          )
+        : null
+    }
+  };
+  const res = jest.fn(() => data);
+  nock('http://localhost')
+    .post('/graphql')
+    .reply(statusCode, res);
+  return res;
+}
+test('does request on init', async () => {
+  const firstCall = mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test'
+      }
+    ]
+  });
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig }
+  });
+  await getPendingResponse(persistedClient);
+  expect(firstCall).toHaveBeenCalled();
+  const channels = await persistedClient.getChannels();
+  expect(channels).toHaveLength(1);
+  expect(channels[0].id).toBe(1);
+});
+test('does request on intervals', async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const channelsPollInterval = 60e3;
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig },
+    channelsPollInterval
+  });
+  {
+    const channels = await persistedClient.getChannels();
+    expect(channels[0].name).toBe('test1');
+  }
+  {
+    mockResponse({
+      channels: [
+        {
+          id: 2,
+          name: 'test2'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(channelsPollInterval + 1);
+    await getPendingResponse(persistedClient);
+    const channels = await persistedClient.getChannels();
+    expect(channels[0].name).toBe('test2');
+  }
+  {
+    mockResponse({
+      channels: [
+        {
+          id: 3,
+          name: 'test3'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(channelsPollInterval);
+    await getPendingResponse(persistedClient);
+    const channels = await persistedClient.getChannels();
+    expect(channels[0].name).toBe('test3');
+  }
+});
+test('propagates bad statusCodes', async () => {
+  mockResponse({ statusCode: 500 });
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig }
+  });
+  expect.assertions(1);
+  try {
+    await getPendingResponse(persistedClient);
+  } catch (err) {
+    expect(err.networkError.statusCode).toBe(500);
+  }
+});
+test('propagates when response contains GraphQL-errors', async () => {
+  const errorMessage = 'Something went wrong';
+  mockResponse({
+    errors: [
+      {
+        message: errorMessage,
+        locations: null
+      }
+    ]
+  });
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig }
+  });
+  expect.assertions(2);
+  try {
+    await getPendingResponse(persistedClient);
+  } catch (_err) {
+    const err = _err;
+    expect(err).toBeInstanceOf(ApolloError);
+    expect(err.message).toBe(`GraphQL error: ${errorMessage}`);
+  }
+});
+test('extracting and using cache in new client', async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const channelsPollInterval = 60e3;
+  const persistedClient = new PersistedApolloClient({
+    createClientOpts: { apolloConfig },
+    channelsPollInterval
+  });
+  await getPendingResponse(persistedClient);
+  {
+    const cache = persistedClient.extractCache();
+    expect(cache).toHaveProperty('Channel:1');
+    expect(cache['Channel:1'].name).toBe('test1');
+    const newClient = new ApolloClient({
+      link: new HttpLink(),
+      cache: new InMemoryCache().restore(cache)
+    });
+    const res = newClient.readQuery({
+      query: channelsQuery
+    });
+    expect(res.channels).toHaveLength(1);
+    expect(res.channels[0].name).toBe('test1');
+  }
+  // update data in new request
+  {
+    const mock = mockResponse({
+      channels: [
+        {
+          id: 1,
+          name: 'test1--updated'
+        },
+        {
+          id: 2,
+          name: 'test2'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(pollInterval);
+    await getPendingResponse(persistedClient);
+    expect(mock).toHaveBeenCalled();
+    const cache = persistedClient.extractCache();
+    const newClient = new ApolloClient({
+      link: new HttpLink(),
+      cache: new InMemoryCache().restore(cache)
+    });
+    const res = newClient.readQuery({
+      query: channelsQuery
+    });
+    expect(res.channels).toHaveLength(2);
+    expect(res.channels[0].name).toBe('test1--updated');
+    expect(res.channels[1].name).toBe('test2');
+  }
+});
+//# sourceMappingURL=PersistedApolloClient.test.js.map

package/boot/server/asyncErrorHandler.d.ts

@@ -1,3 +1,3 @@
-import { RequestHandler } from 'express';
-declare const asyncErrorHandler: (fn: RequestHandler) => RequestHandler;
-export default asyncErrorHandler;
+import { RequestHandler } from 'express';
+declare const asyncErrorHandler: (fn: RequestHandler) => RequestHandler;
+export default asyncErrorHandler;

package/boot/server/asyncErrorHandler.js

@@ -1,5 +1,5 @@
-const asyncErrorHandler = (fn) => (req, res, next) => {
-    Promise.resolve(fn(req, res, next)).catch(next);
-};
-export default asyncErrorHandler;
+const asyncErrorHandler = (fn) => (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+};
+export default asyncErrorHandler;
 //# sourceMappingURL=asyncErrorHandler.js.map

package/boot/server/breakpointMiddleware.d.ts

@@ -1,3 +1,3 @@
-export declare type BreakpointMW = (req: any, res: any, next: any) => void;
-declare const breakpointMiddleware: BreakpointMW;
-export default breakpointMiddleware;
+export declare type BreakpointMW = (req: any, res: any, next: any) => void;
+declare const breakpointMiddleware: BreakpointMW;
+export default breakpointMiddleware;

package/boot/server/breakpointMiddleware.js

@@ -1,10 +1,10 @@
-import MobileDetect from 'mobile-detect';
-// Check if user is on mobile and set breakpoint for rendering
-const breakpointMiddleware = (req, _, next) => {
-    const md = new MobileDetect(req.headers['user-agent']);
-    const isMobile = md.mobile() != null;
-    req.breakpoint = isMobile ? 'sm' : 'lg';
-    next();
-};
-export default breakpointMiddleware;
+import MobileDetect from 'mobile-detect';
+// Check if user is on mobile and set breakpoint for rendering
+const breakpointMiddleware = (req, _, next) => {
+    const md = new MobileDetect(req.headers['user-agent']);
+    const isMobile = md.mobile() != null;
+    req.breakpoint = isMobile ? 'sm' : 'lg';
+    next();
+};
+export default breakpointMiddleware;
 //# sourceMappingURL=breakpointMiddleware.js.map

package/boot/server/createApolloServer.d.ts

@@ -1,28 +1,28 @@
-import { ApolloServer, IResolversParameter } from 'apollo-server-express';
-import { GraphQLSchema } from 'graphql';
-import { ApolloConfig } from '../../components/ConfigProvider';
-import { PluginDefinition } from 'apollo-server-core';
-export interface ForwardedHttpHeaders {
-    [key: string]: string | string[];
-}
-export interface Context {
-    headers: ForwardedHttpHeaders;
-}
-export interface SchemaExtensionOptions {
-    remoteSchema: GraphQLSchema;
-}
-export interface SchemaExtensionResult {
-    schema?: GraphQLSchema | string;
-    resolvers?: IResolversParameter;
-}
-export declare type SchemaExtension = (opts: SchemaExtensionOptions) => PromiseLike<SchemaExtensionResult> | SchemaExtensionResult;
-export declare type SchemaExtensions = SchemaExtension[];
-export interface CreateApolloServerOptions {
-    apolloConfig: ApolloConfig;
-    extensions?: SchemaExtensions;
-    plugins?: PluginDefinition[];
-}
-export default function createApolloServer({ apolloConfig, extensions, plugins }: CreateApolloServerOptions): Promise<{
-    apolloServer: ApolloServer;
-    schema: GraphQLSchema;
-}>;
+import { ApolloServer, IResolversParameter } from 'apollo-server-express';
+import { GraphQLSchema } from 'graphql';
+import { ApolloConfig } from '../../components/ConfigProvider';
+import { PluginDefinition } from 'apollo-server-core';
+export interface ForwardedHttpHeaders {
+    [key: string]: string | string[];
+}
+export interface Context {
+    headers: ForwardedHttpHeaders;
+}
+export interface SchemaExtensionOptions {
+    remoteSchema: GraphQLSchema;
+}
+export interface SchemaExtensionResult {
+    schema?: GraphQLSchema | string;
+    resolvers?: IResolversParameter;
+}
+export declare type SchemaExtension = (opts: SchemaExtensionOptions) => PromiseLike<SchemaExtensionResult> | SchemaExtensionResult;
+export declare type SchemaExtensions = SchemaExtension[];
+export interface CreateApolloServerOptions {
+    apolloConfig: ApolloConfig;
+    extensions?: SchemaExtensions;
+    plugins?: PluginDefinition[];
+}
+export default function createApolloServer({ apolloConfig, extensions, plugins }: CreateApolloServerOptions): Promise<{
+    apolloServer: ApolloServer;
+    schema: GraphQLSchema;
+}>;