@jetshop/core 5.13.2 → 5.13.12-0

package/boot/server/createApolloServer.js

@@ -1,144 +1,144 @@
-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 { ApolloServer, introspectSchema, makeRemoteExecutableSchema, mergeSchemas } from 'apollo-server-express';
-import { HttpLink } from 'apollo-link-http';
-import { setContext } from 'apollo-link-context';
-import fetch from 'node-fetch';
-// import { specifiedRules } from 'graphql';
-// import { OverlappingFieldsCanBeMerged } from 'graphql/validation/rules/OverlappingFieldsCanBeMerged';
-import { InMemoryLRUCache } from 'apollo-server-caching';
-import { ApolloLink } from 'apollo-link';
-import https from 'https';
-import dnscache from 'dnscache';
-const pick = require('lodash.pick');
-const merge = require('lodash.merge');
-// // <😷>
-// // Hack graphql-js to prevent "conflict because they return conflicting types"
-// // https://github.com/graphql/graphql-js/issues/1361#issuecomment-393489320
-// // The underlying .NET GraphQL-API does not have this check
-// // https://github.com/graphql-dotnet/graphql-dotnet/issues/160
-// const index = specifiedRules.findIndex(
-//   item => item === OverlappingFieldsCanBeMerged
-// );
-// (specifiedRules as any[]).splice(index, 1);
-// // </😷>
-const forwardedHeaders = [
-    'authorization',
-    'channelid',
-    'country',
-    'culture',
-    'currency'
-];
-function getRemoteSchema({ apolloConfig: { graphQLURI, token, shopid } }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const http = new HttpLink({
-            uri: graphQLURI,
-            fetch: fetch,
-            fetchOptions: {
-                agent: graphQLURI.indexOf('https') === 0
-                    ? new https.Agent({
-                        keepAlive: true
-                    })
-                    : undefined
-            }
-        });
-        // on introspect, get headers from conf/env
-        const introspectLink = setContext(() => ({
-            headers: {
-                token,
-                shopid
-            }
-        })).concat(http);
-        // proxy: on incoming request, forward headers
-        const forwardLink = setContext((_request, context) => {
-            const ctx = context.graphqlContext;
-            return {
-                headers: Object.assign({ token,
-                    shopid }, ctx.headers)
-            };
-        }).concat(http);
-        /**
-         * FIXME
-         * Hack to get errors forwarded.
-         * Can probably removed after the issue below has been resolved.
-         * @link https://github.com/apollographql/graphql-tools/issues/1046#issuecomment-457445794
-         */
-        const errorLink = new ApolloLink((operation, forward) => {
-            return forward(operation).map(data => {
-                if (data.errors) {
-                    for (const error of data.errors) {
-                        if (!(error instanceof Error))
-                            Object.setPrototypeOf(error, Error.prototype);
-                    }
-                }
-                return data;
-            });
-        });
-        // We could do this build-time to speed up start
-        const schema = yield introspectSchema(introspectLink);
-        const executableSchema = makeRemoteExecutableSchema({
-            schema,
-            link: errorLink.concat(forwardLink)
-        });
-        return executableSchema;
-    });
-}
-export default function createApolloServer({ apolloConfig, extensions = [], plugins = [] }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        dnscache({
-            enable: true,
-            ttl: 300,
-            cachesize: 1000
-        });
-        const remoteSchema = yield getRemoteSchema({ apolloConfig });
-        const schemas = [remoteSchema];
-        const resolvers = {};
-        for (const extension of extensions) {
-            const result = yield extension({ remoteSchema });
-            if (result.schema) {
-                schemas.push(result.schema);
-            }
-            if (result.resolvers) {
-                merge(resolvers, result.resolvers);
-            }
-        }
-        const schema = mergeSchemas({
-            schemas,
-            resolvers
-        });
-        const engine = apolloConfig.engineApiKey
-            ? {
-                apiKey: apolloConfig.engineApiKey
-            }
-            : false;
-        const apolloServer = new ApolloServer({
-            schema,
-            // Disable introspection in production
-            introspection: process.env.NODE_ENV !== 'production',
-            context: ({ req }) => {
-                var _a;
-                const incomingHeaders = (_a = req === null || req === void 0 ? void 0 : req.headers) !== null && _a !== void 0 ? _a : {};
-                const headers = pick(incomingHeaders, forwardedHeaders);
-                return {
-                    headers
-                };
-            },
-            persistedQueries: {
-                cache: new InMemoryLRUCache()
-            },
-            tracing: false,
-            cacheControl: false,
-            engine,
-            plugins
-        });
-        return { apolloServer, schema };
-    });
-}
+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 { ApolloServer, introspectSchema, makeRemoteExecutableSchema, mergeSchemas } from 'apollo-server-express';
+import { HttpLink } from 'apollo-link-http';
+import { setContext } from 'apollo-link-context';
+import fetch from 'node-fetch';
+// import { specifiedRules } from 'graphql';
+// import { OverlappingFieldsCanBeMerged } from 'graphql/validation/rules/OverlappingFieldsCanBeMerged';
+import { InMemoryLRUCache } from 'apollo-server-caching';
+import { ApolloLink } from 'apollo-link';
+import https from 'https';
+import dnscache from 'dnscache';
+const pick = require('lodash.pick');
+const merge = require('lodash.merge');
+// // <😷>
+// // Hack graphql-js to prevent "conflict because they return conflicting types"
+// // https://github.com/graphql/graphql-js/issues/1361#issuecomment-393489320
+// // The underlying .NET GraphQL-API does not have this check
+// // https://github.com/graphql-dotnet/graphql-dotnet/issues/160
+// const index = specifiedRules.findIndex(
+//   item => item === OverlappingFieldsCanBeMerged
+// );
+// (specifiedRules as any[]).splice(index, 1);
+// // </😷>
+const forwardedHeaders = [
+    'authorization',
+    'channelid',
+    'country',
+    'culture',
+    'currency'
+];
+function getRemoteSchema({ apolloConfig: { graphQLURI, token, shopid } }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const http = new HttpLink({
+            uri: graphQLURI,
+            fetch: fetch,
+            fetchOptions: {
+                agent: graphQLURI.indexOf('https') === 0
+                    ? new https.Agent({
+                        keepAlive: true
+                    })
+                    : undefined
+            }
+        });
+        // on introspect, get headers from conf/env
+        const introspectLink = setContext(() => ({
+            headers: {
+                token,
+                shopid
+            }
+        })).concat(http);
+        // proxy: on incoming request, forward headers
+        const forwardLink = setContext((_request, context) => {
+            const ctx = context.graphqlContext;
+            return {
+                headers: Object.assign({ token,
+                    shopid }, ctx.headers)
+            };
+        }).concat(http);
+        /**
+         * FIXME
+         * Hack to get errors forwarded.
+         * Can probably removed after the issue below has been resolved.
+         * @link https://github.com/apollographql/graphql-tools/issues/1046#issuecomment-457445794
+         */
+        const errorLink = new ApolloLink((operation, forward) => {
+            return forward(operation).map(data => {
+                if (data.errors) {
+                    for (const error of data.errors) {
+                        if (!(error instanceof Error))
+                            Object.setPrototypeOf(error, Error.prototype);
+                    }
+                }
+                return data;
+            });
+        });
+        // We could do this build-time to speed up start
+        const schema = yield introspectSchema(introspectLink);
+        const executableSchema = makeRemoteExecutableSchema({
+            schema,
+            link: errorLink.concat(forwardLink)
+        });
+        return executableSchema;
+    });
+}
+export default function createApolloServer({ apolloConfig, extensions = [], plugins = [] }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        dnscache({
+            enable: true,
+            ttl: 300,
+            cachesize: 1000
+        });
+        const remoteSchema = yield getRemoteSchema({ apolloConfig });
+        const schemas = [remoteSchema];
+        const resolvers = {};
+        for (const extension of extensions) {
+            const result = yield extension({ remoteSchema });
+            if (result.schema) {
+                schemas.push(result.schema);
+            }
+            if (result.resolvers) {
+                merge(resolvers, result.resolvers);
+            }
+        }
+        const schema = mergeSchemas({
+            schemas,
+            resolvers
+        });
+        const engine = apolloConfig.engineApiKey
+            ? {
+                apiKey: apolloConfig.engineApiKey
+            }
+            : false;
+        const apolloServer = new ApolloServer({
+            schema,
+            // Disable introspection in production
+            introspection: process.env.NODE_ENV !== 'production',
+            context: ({ req }) => {
+                var _a;
+                const incomingHeaders = (_a = req === null || req === void 0 ? void 0 : req.headers) !== null && _a !== void 0 ? _a : {};
+                const headers = pick(incomingHeaders, forwardedHeaders);
+                return {
+                    headers
+                };
+            },
+            persistedQueries: {
+                cache: new InMemoryLRUCache()
+            },
+            tracing: false,
+            cacheControl: false,
+            engine,
+            plugins
+        });
+        return { apolloServer, schema };
+    });
+}
 //# sourceMappingURL=createApolloServer.js.map

package/boot/server/createApolloServer.test.js

@@ -1,114 +1,114 @@
-import express from 'express';
-import { ApolloServer, gql } from 'apollo-server-express';
-import listen from './listen';
-import createApolloServer from './createApolloServer';
-import fetch from 'node-fetch';
-import { GraphQLError } from 'graphql';
-
-function createGraphqlClient(port) {
-  const url = `http://localhost:${port}/graphql`;
-
-  return async function request({ query, variables }) {
-    const body = { query, variables };
-
-    const resBody = await fetch(url, {
-      method: 'post',
-      body: JSON.stringify(body),
-      headers: { 'Content-Type': 'application/json' }
-    }).then(r => r.json());
-
-    return resBody;
-  };
-}
-
-async function createTargetServer() {
-  const typeDefs = gql`
-    type Query {
-      hello(name: String!): String!
-    }
-  `;
-
-  const resolvers = {
-    Query: {
-      hello: async (_source, { name }) => {
-        if (name === '') {
-          throw new GraphQLError(`Name can't be empty`);
-        }
-
-        return `Hello ${name}`;
-      }
-    }
-  };
-
-  const apolloServer = new ApolloServer({
-    typeDefs,
-    resolvers
-  });
-
-  const app = express();
-
-  apolloServer.applyMiddleware({ app });
-
-  const { port, close } = await listen({ app, port: 0 });
-  const query = createGraphqlClient(port);
-
-  return { port, close, query };
-}
-async function createLocalServer({ targetPort }) {
-  const { apolloServer } = await createApolloServer({
-    apolloConfig: {
-      graphQLURI: `http://localhost:${targetPort}/graphql`
-    }
-  });
-
-  const app = express();
-  apolloServer.applyMiddleware({ app });
-
-  const { port, close } = await listen({ app, port: 0 });
-  const query = createGraphqlClient(port);
-
-  return { port, close, query };
-}
-
-let targetServer;
-let localServer;
-
-afterEach(async () => {
-  if (localServer) {
-    await localServer.close();
-  }
-  if (targetServer) {
-    await targetServer.close();
-  }
-  localServer = null;
-  targetServer = null;
-});
-
-test('forwarding queries', async () => {
-  targetServer = await createTargetServer();
-  localServer = await createLocalServer({ targetPort: targetServer.port });
-
-  const { data } = await localServer.query({
-    query: '{ hello(name: "World") }'
-  });
-
-  expect(data.hello).toBe('Hello World');
-});
-
-test('propagating errors', async () => {
-  targetServer = await createTargetServer();
-  localServer = await createLocalServer({ targetPort: targetServer.port });
-
-  const query = '{ hello(name: "") }'; // should trigger "Name can't be empty"
-
-  const { errors: expectedErrors } = await targetServer.query({ query });
-  const { errors: actualErrors } = await localServer.query({ query });
-
-  expect(expectedErrors).toHaveLength(1);
-  expect(actualErrors).toHaveLength(1);
-
-  expect(expectedErrors[0].message).toBe(`Name can't be empty`);
-
-  expect(actualErrors[0].message).toBe(expectedErrors[0].message);
-  expect(actualErrors[0].path).toEqual(expectedErrors[0].path);
-});
+import express from 'express';
+import { ApolloServer, gql } from 'apollo-server-express';
+import listen from './listen';
+import createApolloServer from './createApolloServer';
+import fetch from 'node-fetch';
+import { GraphQLError } from 'graphql';
+
+function createGraphqlClient(port) {
+  const url = `http://localhost:${port}/graphql`;
+
+  return async function request({ query, variables }) {
+    const body = { query, variables };
+
+    const resBody = await fetch(url, {
+      method: 'post',
+      body: JSON.stringify(body),
+      headers: { 'Content-Type': 'application/json' }
+    }).then(r => r.json());
+
+    return resBody;
+  };
+}
+
+async function createTargetServer() {
+  const typeDefs = gql`
+    type Query {
+      hello(name: String!): String!
+    }
+  `;
+
+  const resolvers = {
+    Query: {
+      hello: async (_source, { name }) => {
+        if (name === '') {
+          throw new GraphQLError(`Name can't be empty`);
+        }
+
+        return `Hello ${name}`;
+      }
+    }
+  };
+
+  const apolloServer = new ApolloServer({
+    typeDefs,
+    resolvers
+  });
+
+  const app = express();
+
+  apolloServer.applyMiddleware({ app });
+
+  const { port, close } = await listen({ app, port: 0 });
+  const query = createGraphqlClient(port);
+
+  return { port, close, query };
+}
+async function createLocalServer({ targetPort }) {
+  const { apolloServer } = await createApolloServer({
+    apolloConfig: {
+      graphQLURI: `http://localhost:${targetPort}/graphql`
+    }
+  });
+
+  const app = express();
+  apolloServer.applyMiddleware({ app });
+
+  const { port, close } = await listen({ app, port: 0 });
+  const query = createGraphqlClient(port);
+
+  return { port, close, query };
+}
+
+let targetServer;
+let localServer;
+
+afterEach(async () => {
+  if (localServer) {
+    await localServer.close();
+  }
+  if (targetServer) {
+    await targetServer.close();
+  }
+  localServer = null;
+  targetServer = null;
+});
+
+test('forwarding queries', async () => {
+  targetServer = await createTargetServer();
+  localServer = await createLocalServer({ targetPort: targetServer.port });
+
+  const { data } = await localServer.query({
+    query: '{ hello(name: "World") }'
+  });
+
+  expect(data.hello).toBe('Hello World');
+});
+
+test('propagating errors', async () => {
+  targetServer = await createTargetServer();
+  localServer = await createLocalServer({ targetPort: targetServer.port });
+
+  const query = '{ hello(name: "") }'; // should trigger "Name can't be empty"
+
+  const { errors: expectedErrors } = await targetServer.query({ query });
+  const { errors: actualErrors } = await localServer.query({ query });
+
+  expect(expectedErrors).toHaveLength(1);
+  expect(actualErrors).toHaveLength(1);
+
+  expect(expectedErrors[0].message).toBe(`Name can't be empty`);
+
+  expect(actualErrors[0].message).toBe(expectedErrors[0].message);
+  expect(actualErrors[0].path).toEqual(expectedErrors[0].path);
+});

package/boot/server/createDevServer.d.ts

@@ -1,14 +1,14 @@
-import { ApolloConfig } from '../../components/ConfigProvider';
-import { SchemaExtensions } from './createApolloServer';
-import { PluginDefinition } from 'apollo-server-core';
-export interface CreateDevServerOptions {
-    apolloConfig: ApolloConfig;
-    port: number;
-    schemaExtensions?: SchemaExtensions;
-    apolloServerPlugins?: PluginDefinition[];
-}
-export declare const createDevServer: ({ apolloConfig, port, schemaExtensions, apolloServerPlugins }: CreateDevServerOptions) => Promise<{
-    port: number;
-    apolloServer: import("apollo-server-express").ApolloServer;
-}>;
-export default createDevServer;
+import { ApolloConfig } from '../../components/ConfigProvider';
+import { SchemaExtensions } from './createApolloServer';
+import { PluginDefinition } from 'apollo-server-core';
+export interface CreateDevServerOptions {
+    apolloConfig: ApolloConfig;
+    port: number;
+    schemaExtensions?: SchemaExtensions;
+    apolloServerPlugins?: PluginDefinition[];
+}
+export declare const createDevServer: ({ apolloConfig, port, schemaExtensions, apolloServerPlugins }: CreateDevServerOptions) => Promise<{
+    port: number;
+    apolloServer: import("apollo-server-express").ApolloServer;
+}>;
+export default createDevServer;

package/boot/server/createDevServer.js

@@ -1,30 +1,30 @@
-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 * as cors from 'cors';
-import * as express from 'express';
-import createApolloServer from './createApolloServer';
-import listen from './listen';
-export const createDevServer = ({ apolloConfig, port, schemaExtensions, apolloServerPlugins }) => __awaiter(void 0, void 0, void 0, function* () {
-    const app = express();
-    app.use(cors());
-    const { apolloServer } = yield createApolloServer({
-        apolloConfig,
-        extensions: schemaExtensions,
-        plugins: apolloServerPlugins
-    });
-    apolloServer.applyMiddleware({ app: app });
-    const { port: listenPort } = yield listen({
-        app,
-        port
-    });
-    return { port: listenPort, apolloServer };
-});
-export default createDevServer;
+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 * as cors from 'cors';
+import * as express from 'express';
+import createApolloServer from './createApolloServer';
+import listen from './listen';
+export const createDevServer = ({ apolloConfig, port, schemaExtensions, apolloServerPlugins }) => __awaiter(void 0, void 0, void 0, function* () {
+    const app = express();
+    app.use(cors());
+    const { apolloServer } = yield createApolloServer({
+        apolloConfig,
+        extensions: schemaExtensions,
+        plugins: apolloServerPlugins
+    });
+    apolloServer.applyMiddleware({ app: app });
+    const { port: listenPort } = yield listen({
+        app,
+        port
+    });
+    return { port: listenPort, apolloServer };
+});
+export default createDevServer;
 //# sourceMappingURL=createDevServer.js.map

package/boot/server/createRenderer.d.ts

@@ -1,28 +1,28 @@
-import { Request, Response } from 'express';
-import { GraphQLSchema } from 'graphql';
-import { ReactElement } from 'react';
-import { Cookies } from 'react-cookie';
-import { Tracker } from '../../analytics/tracking';
-import { BootOptions, OptimizeConfig } from '../../components/ConfigProvider';
-import { PersistedApolloClient } from './PersistedApolloClient';
-export interface SlotData {
-    [key: string]: string;
-}
-export interface PreloadScripts {
-    src: string;
-    attrs: SlotData;
-}
-export interface RendererOptions extends BootOptions {
-    loadableStatsPath: string;
-    schema?: GraphQLSchema;
-    disableGeoRedirect: boolean;
-    singleDomainMode: boolean;
-    trackers?: Tracker[];
-    optimize?: OptimizeConfig;
-    globalClient?: PersistedApolloClient;
-}
-declare const createRenderer: (template: string, tree: ReactElement<any>, options: RendererOptions) => (req: Request & {
-    universalCookies: Cookies;
-    breakpoint: string;
-}, res: Response) => Promise<void>;
-export default createRenderer;
+import { Request, Response } from 'express';
+import { GraphQLSchema } from 'graphql';
+import { ReactElement } from 'react';
+import { Cookies } from 'react-cookie';
+import { Tracker } from '../../analytics/tracking';
+import { BootOptions, OptimizeConfig } from '../../components/ConfigProvider';
+import { PersistedApolloClient } from './PersistedApolloClient';
+export interface SlotData {
+    [key: string]: string;
+}
+export interface PreloadScripts {
+    src: string;
+    attrs: SlotData;
+}
+export interface RendererOptions extends BootOptions {
+    loadableStatsPath: string;
+    schema?: GraphQLSchema;
+    disableGeoRedirect: boolean;
+    singleDomainMode: boolean;
+    trackers?: Tracker[];
+    optimize?: OptimizeConfig;
+    globalClient?: PersistedApolloClient;
+}
+declare const createRenderer: (template: string, tree: ReactElement<any>, options: RendererOptions) => (req: Request & {
+    universalCookies: Cookies;
+    breakpoint: string;
+}, res: Response) => Promise<void>;
+export default createRenderer;