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

package/boot/server/IntervalQuery.test.js

@@ -1,280 +1,280 @@
-// 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/IntervalQuery.test.ts
-
-import { InMemoryCache } from 'apollo-cache-inmemory';
-import { HttpLink } from 'apollo-link-http';
-import ApolloClient, { ApolloError } from 'apollo-client';
-import { IntervalQuery } from './IntervalQuery';
-import nock from 'nock';
-import gql from 'graphql-tag';
-beforeAll(() => {
-  jest.useFakeTimers();
-  nock.disableNetConnect();
-});
-afterAll(() => {
-  jest.useRealTimers();
-  nock.enableNetConnect();
-});
-afterEach(() => {
-  jest.restoreAllMocks();
-  jest.clearAllTimers();
-  nock.enableNetConnect();
-});
-const query = gql`
-  query ChannelsQuery {
-    channels {
-      id
-      name
-    }
-  }
-`;
-const apolloConfig = {
-  shopid: '...',
-  graphQLURI: 'http://localhost/graphql',
-  token: '...',
-  enableGateway: false
-};
-
-/**
- * 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' }, 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 intervalQuery = new IntervalQuery({
-    createClientOpts: { apolloConfig },
-    query,
-    pollInterval: 60e3
-  });
-  await intervalQuery.getPendingResponse();
-  expect(firstCall).toHaveBeenCalled();
-  const res = await intervalQuery.results();
-  expect(res.channels).toHaveLength(1);
-  expect(res.channels[0].id).toBe(1);
-});
-test('does request on intervals', async () => {
-  mockResponse({
-    channels: [
-      {
-        id: 1,
-        name: 'test1'
-      }
-    ]
-  });
-  const pollInterval = 60e3;
-  const intervalQuery = new IntervalQuery({
-    createClientOpts: { apolloConfig },
-    query,
-    pollInterval
-  });
-  {
-    const res = await intervalQuery.results();
-    expect(res.channels[0].name).toBe('test1');
-    nock.cleanAll();
-  }
-  {
-    const mock = mockResponse({
-      channels: [
-        {
-          id: 2,
-          name: 'test2'
-        }
-      ]
-    });
-    jest.advanceTimersByTime(pollInterval);
-    await intervalQuery.getPendingResponse();
-    const res = await intervalQuery.results();
-    expect(mock).toHaveBeenCalled();
-    expect(res.channels[0].name).toBe('test2');
-  }
-  {
-    mockResponse({
-      channels: [
-        {
-          id: 3,
-          name: 'test3'
-        }
-      ]
-    });
-    jest.advanceTimersByTime(pollInterval);
-    await intervalQuery.getPendingResponse();
-    const res = await intervalQuery.results();
-    expect(res.channels[0].name).toBe('test3');
-  }
-});
-test('propagates bad statusCodes', async () => {
-  mockResponse({ statusCode: 500 });
-  const onError = jest.fn();
-  const pollInterval = 60e3;
-  const intervalQuery = new IntervalQuery({
-    createClientOpts: { apolloConfig },
-    query,
-    pollInterval,
-    onError
-  });
-  expect.assertions(3);
-  try {
-    await intervalQuery.getPendingResponse();
-  } catch (err) {
-    expect(err.networkError.statusCode).toBe(500);
-    expect(onError).toHaveBeenCalledTimes(1);
-  }
-  // successful response after
-  mockResponse({ channels: [] });
-  const res = await intervalQuery.results();
-  expect(res.channels).toEqual([]);
-});
-test('propagates when response contains GraphQL-errors', async () => {
-  const errorMessage = 'Something went wrong';
-  mockResponse({
-    errors: [
-      {
-        message: errorMessage,
-        locations: null
-      }
-    ]
-  });
-  const pollInterval = 60e3;
-  const intervalQuery = new IntervalQuery({
-    createClientOpts: { apolloConfig },
-    query,
-    pollInterval
-  });
-  expect.assertions(2);
-  try {
-    await intervalQuery.getPendingResponse();
-  } 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 intervalQuery = new IntervalQuery({
-    createClientOpts: { apolloConfig },
-    query,
-    pollInterval
-  });
-  await intervalQuery.getPendingResponse();
-  {
-    const cache = intervalQuery.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
-    });
-    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 intervalQuery.getPendingResponse();
-    expect(mock).toHaveBeenCalled();
-    const cache = intervalQuery.extractCache();
-    const newClient = new ApolloClient({
-      link: new HttpLink(),
-      cache: new InMemoryCache().restore(cache)
-    });
-    const res = newClient.readQuery({
-      query
-    });
-    expect(res.channels).toHaveLength(2);
-    expect(res.channels[0].name).toBe('test1--updated');
-    expect(res.channels[1].name).toBe('test2');
-  }
-});
-
-test(`internal state doesn't get overridden by erroneous requests`, async () => {
-  mockResponse({
-    channels: [
-      {
-        id: 1,
-        name: 'test1'
-      }
-    ]
-  });
-  const pollInterval = 60e3;
-  const intervalQuery = new IntervalQuery({
-    createClientOpts: { apolloConfig },
-    query,
-    pollInterval
-  });
-  await intervalQuery.getPendingResponse();
-
-  mockResponse({
-    errors: [
-      {
-        message: 'Something went wrong',
-        locations: null
-      }
-    ]
-  });
-  jest.advanceTimersByTime(pollInterval);
-  let err;
-  try {
-    await intervalQuery.getPendingResponse();
-  } catch (_err) {
-    err = _err;
-  }
-  expect(err).toBeInstanceOf(Error);
-
-  const cache = intervalQuery.extractCache();
-  expect(cache['Channel:1']).toBeTruthy();
-  expect(cache['Channel:1'].name).toBe('test1');
-
-  const res = await intervalQuery.results();
-
-  expect(res.channels[0].name).toBe('test1');
-});
+// 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/IntervalQuery.test.ts
+
+import { InMemoryCache } from 'apollo-cache-inmemory';
+import { HttpLink } from 'apollo-link-http';
+import ApolloClient, { ApolloError } from 'apollo-client';
+import { IntervalQuery } from './IntervalQuery';
+import nock from 'nock';
+import gql from 'graphql-tag';
+beforeAll(() => {
+  jest.useFakeTimers();
+  nock.disableNetConnect();
+});
+afterAll(() => {
+  jest.useRealTimers();
+  nock.enableNetConnect();
+});
+afterEach(() => {
+  jest.restoreAllMocks();
+  jest.clearAllTimers();
+  nock.enableNetConnect();
+});
+const query = gql`
+  query ChannelsQuery {
+    channels {
+      id
+      name
+    }
+  }
+`;
+const apolloConfig = {
+  shopid: '...',
+  graphQLURI: 'http://localhost/graphql',
+  token: '...',
+  enableGateway: false
+};
+
+/**
+ * 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' }, 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 intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval: 60e3
+  });
+  await intervalQuery.getPendingResponse();
+  expect(firstCall).toHaveBeenCalled();
+  const res = await intervalQuery.results();
+  expect(res.channels).toHaveLength(1);
+  expect(res.channels[0].id).toBe(1);
+});
+test('does request on intervals', async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval
+  });
+  {
+    const res = await intervalQuery.results();
+    expect(res.channels[0].name).toBe('test1');
+    nock.cleanAll();
+  }
+  {
+    const mock = mockResponse({
+      channels: [
+        {
+          id: 2,
+          name: 'test2'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(pollInterval);
+    await intervalQuery.getPendingResponse();
+    const res = await intervalQuery.results();
+    expect(mock).toHaveBeenCalled();
+    expect(res.channels[0].name).toBe('test2');
+  }
+  {
+    mockResponse({
+      channels: [
+        {
+          id: 3,
+          name: 'test3'
+        }
+      ]
+    });
+    jest.advanceTimersByTime(pollInterval);
+    await intervalQuery.getPendingResponse();
+    const res = await intervalQuery.results();
+    expect(res.channels[0].name).toBe('test3');
+  }
+});
+test('propagates bad statusCodes', async () => {
+  mockResponse({ statusCode: 500 });
+  const onError = jest.fn();
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval,
+    onError
+  });
+  expect.assertions(3);
+  try {
+    await intervalQuery.getPendingResponse();
+  } catch (err) {
+    expect(err.networkError.statusCode).toBe(500);
+    expect(onError).toHaveBeenCalledTimes(1);
+  }
+  // successful response after
+  mockResponse({ channels: [] });
+  const res = await intervalQuery.results();
+  expect(res.channels).toEqual([]);
+});
+test('propagates when response contains GraphQL-errors', async () => {
+  const errorMessage = 'Something went wrong';
+  mockResponse({
+    errors: [
+      {
+        message: errorMessage,
+        locations: null
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval
+  });
+  expect.assertions(2);
+  try {
+    await intervalQuery.getPendingResponse();
+  } 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 intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval
+  });
+  await intervalQuery.getPendingResponse();
+  {
+    const cache = intervalQuery.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
+    });
+    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 intervalQuery.getPendingResponse();
+    expect(mock).toHaveBeenCalled();
+    const cache = intervalQuery.extractCache();
+    const newClient = new ApolloClient({
+      link: new HttpLink(),
+      cache: new InMemoryCache().restore(cache)
+    });
+    const res = newClient.readQuery({
+      query
+    });
+    expect(res.channels).toHaveLength(2);
+    expect(res.channels[0].name).toBe('test1--updated');
+    expect(res.channels[1].name).toBe('test2');
+  }
+});
+
+test(`internal state doesn't get overridden by erroneous requests`, async () => {
+  mockResponse({
+    channels: [
+      {
+        id: 1,
+        name: 'test1'
+      }
+    ]
+  });
+  const pollInterval = 60e3;
+  const intervalQuery = new IntervalQuery({
+    createClientOpts: { apolloConfig },
+    query,
+    pollInterval
+  });
+  await intervalQuery.getPendingResponse();
+
+  mockResponse({
+    errors: [
+      {
+        message: 'Something went wrong',
+        locations: null
+      }
+    ]
+  });
+  jest.advanceTimersByTime(pollInterval);
+  let err;
+  try {
+    await intervalQuery.getPendingResponse();
+  } catch (_err) {
+    err = _err;
+  }
+  expect(err).toBeInstanceOf(Error);
+
+  const cache = intervalQuery.extractCache();
+  expect(cache['Channel:1']).toBeTruthy();
+  expect(cache['Channel:1'].name).toBe('test1');
+
+  const res = await intervalQuery.results();
+
+  expect(res.channels[0].name).toBe('test1');
+});

package/boot/server/PersistedApolloClient.d.ts

@@ -1,20 +1,20 @@
-import { Channel } from '@jetshop/core/types';
-import { CreateClientOpts } from '../apollo';
-/**
- * Persisted Apollo Client that's shared across all requests on the server
- */
-export declare class PersistedApolloClient {
-    /**
-     * **⚠️ WARNING ⚠️**
-     *
-     * Use this client with care as it's cache will be shared amongst **all** requests
-     * It's private in this class for us to be able to expose only specific queries
-     */
-    private channelsIntervalQuery;
-    constructor({ createClientOpts, channelsPollInterval }: {
-        createClientOpts: CreateClientOpts;
-        channelsPollInterval?: number;
-    });
-    extractCache(): any;
-    getChannels(): Promise<Channel[]>;
-}
+import { Channel } from '@jetshop/core/types';
+import { CreateClientOpts } from '../apollo';
+/**
+ * Persisted Apollo Client that's shared across all requests on the server
+ */
+export declare class PersistedApolloClient {
+    /**
+     * **⚠️ WARNING ⚠️**
+     *
+     * Use this client with care as it's cache will be shared amongst **all** requests
+     * It's private in this class for us to be able to expose only specific queries
+     */
+    private channelsIntervalQuery;
+    constructor({ createClientOpts, channelsPollInterval }: {
+        createClientOpts: CreateClientOpts;
+        channelsPollInterval?: number;
+    });
+    extractCache(): any;
+    getChannels(): Promise<Channel[]>;
+}

package/boot/server/PersistedApolloClient.js

@@ -1,40 +1,40 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import logWarningInDev from '../../helpers/logWarningInDev';
-import channelsQueryDefault from '../ChannelsQuery.gql';
-import { IntervalQuery } from './IntervalQuery';
-/**
- * Persisted Apollo Client that's shared across all requests on the server
- */
-export class PersistedApolloClient {
-    constructor({ createClientOpts, channelsPollInterval = 60e3 }) {
-        const { apolloConfig } = createClientOpts;
-        if (!apolloConfig.channelsQuery) {
-            logWarningInDev(true, `Using PersistedApolloClient without supplying the channelsQuery is deprecated and will break in the next major release.`);
-            apolloConfig.channelsQuery = channelsQueryDefault;
-        }
-        this.channelsIntervalQuery = new IntervalQuery({
-            query: apolloConfig.channelsQuery,
-            createClientOpts,
-            pollInterval: channelsPollInterval
-        });
-    }
-    extractCache() {
-        return this.channelsIntervalQuery.extractCache();
-    }
-    getChannels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.channelsIntervalQuery.results();
-            const channels = res.channels;
-            return channels;
-        });
-    }
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import logWarningInDev from '../../helpers/logWarningInDev';
+import channelsQueryDefault from '../ChannelsQuery.gql';
+import { IntervalQuery } from './IntervalQuery';
+/**
+ * Persisted Apollo Client that's shared across all requests on the server
+ */
+export class PersistedApolloClient {
+    constructor({ createClientOpts, channelsPollInterval = 60e3 }) {
+        const { apolloConfig } = createClientOpts;
+        if (!apolloConfig.channelsQuery) {
+            logWarningInDev(true, `Using PersistedApolloClient without supplying the channelsQuery is deprecated and will break in the next major release.`);
+            apolloConfig.channelsQuery = channelsQueryDefault;
+        }
+        this.channelsIntervalQuery = new IntervalQuery({
+            query: apolloConfig.channelsQuery,
+            createClientOpts,
+            pollInterval: channelsPollInterval
+        });
+    }
+    extractCache() {
+        return this.channelsIntervalQuery.extractCache();
+    }
+    getChannels() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.channelsIntervalQuery.results();
+            const channels = res.channels;
+            return channels;
+        });
+    }
+}
 //# sourceMappingURL=PersistedApolloClient.js.map