@jetshop/core 6.3.7 → 6.3.8-alpha.18

package/boot/server/IntervalQuery.test.js

@@ -1,276 +0,0 @@
-import {
-  ApolloClient,
-  ApolloError,
-  InMemoryCache,
-  HttpLink,
-  gql
-} from '@apollo/client';
-import { IntervalQuery } from './IntervalQuery';
-import nock from 'nock';
-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 +0,0 @@
-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 +0,0 @@
-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

package/boot/server/PersistedApolloClient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PersistedApolloClient.js","sourceRoot":"","sources":["PersistedApolloClient.ts"],"names":[],"mappings":";;;;;;;;;AACA,OAAO,eAAe,MAAM,+BAA+B,CAAC;AAE5D,OAAO,oBAAoB,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAMhD;;GAEG;AACH,MAAM,OAAO,qBAAqB;IAShC,YAAY,EACV,gBAAgB,EAChB,oBAAoB,GAAG,IAAI,EAI5B;QACC,MAAM,EAAE,YAAY,EAAE,GAAG,gBAAgB,CAAC;QAC1C,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE;YAC/B,eAAe,CACb,IAAI,EACJ,yHAAyH,CAC1H,CAAC;YACF,YAAY,CAAC,aAAa,GAAG,oBAAoB,CAAC;SACnD;QAED,IAAI,CAAC,qBAAqB,GAAG,IAAI,aAAa,CAAC;YAC7C,KAAK,EAAE,YAAY,CAAC,aAAa;YACjC,gBAAgB;YAChB,YAAY,EAAE,oBAAoB;SACnC,CAAC,CAAC;IACL,CAAC;IAEM,YAAY;QACjB,OAAO,IAAI,CAAC,qBAAqB,CAAC,YAAY,EAAE,CAAC;IACnD,CAAC;IAEY,WAAW;;YACtB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,EAAE,CAAC;YAEvD,MAAM,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC;YAE9B,OAAO,QAAQ,CAAC;QAClB,CAAC;KAAA;CACF"}

package/boot/server/PersistedApolloClient.test.js

@@ -1,234 +0,0 @@
-// 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,
-  InMemoryCache,
-  HttpLink
-} from '@apollo/client';
-import { PersistedApolloClient } from './PersistedApolloClient';
-import nock from 'nock';
-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 +0,0 @@
-import { RequestHandler } from 'express';
-declare const asyncErrorHandler: (fn: RequestHandler) => RequestHandler;
-export default asyncErrorHandler;

package/boot/server/asyncErrorHandler.js

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

package/boot/server/asyncErrorHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncErrorHandler.js","sourceRoot":"","sources":["asyncErrorHandler.ts"],"names":[],"mappings":"AAEA,MAAM,iBAAiB,GAAG,CAAC,EAAkB,EAAkB,EAAE,CAAC,CAChE,GAAG,EACH,GAAG,EACH,IAAI,EACJ,EAAE;IACF,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAClD,CAAC,CAAC;AAEF,eAAe,iBAAiB,CAAC"}

package/boot/server/breakpointMiddleware.d.ts

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

package/boot/server/breakpointMiddleware.js

@@ -1,10 +0,0 @@
-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/breakpointMiddleware.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"breakpointMiddleware.js","sourceRoot":"","sources":["breakpointMiddleware.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAC;AAIzC,8DAA8D;AAC9D,MAAM,oBAAoB,GAAiB,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE;IAC1D,MAAM,EAAE,GAAG,IAAI,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,EAAE,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC;IAErC,GAAG,CAAC,UAAU,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IACxC,IAAI,EAAE,CAAC;AACT,CAAC,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/boot/server/createApolloServer.d.ts

@@ -1,29 +0,0 @@
-import { ApolloServer } from 'apollo-server-express';
-import { IResolversParameter } from 'graphql-tools';
-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 type SchemaExtension = (opts: SchemaExtensionOptions) => PromiseLike<SchemaExtensionResult> | SchemaExtensionResult;
-export 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;
-}>;