@jetshop/core 5.13.12-0 → 5.14.0

package/server/graphql.test.js

@@ -1,123 +1,123 @@
-import express from 'express';
-import { graphqlHTTP } from 'express-graphql';
-import { makeExecutableSchema } from '@graphql-tools/schema';
-import listen from '../boot/server/listen';
-import { createExtension, createGraphqlServer } from './graphql';
-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 = `
-  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 app = express();
-  app.use(
-    '/graphql',
-    graphqlHTTP({
-      schema: makeExecutableSchema({
-        typeDefs,
-        resolvers
-      })
-    })
-  );
-
-  const { port, close } = await listen({ app, port: 0 });
-  const query = createGraphqlClient(port);
-
-  return { port, close, query };
-}
-
-async function createLocalServer({ targetPort }) {
-  const graphqlServer = await createGraphqlServer({
-    extensions: [
-      createExtension({
-        endpoint: `http://localhost:${targetPort}/graphql`,
-        getHeaders: () => ({
-          'Content-Type': 'application/json'
-        })
-      })
-    ]
-  });
-
-  const app = express();
-  app.use('/graphql', graphqlServer);
-
-  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.only('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 { graphqlHTTP } from 'express-graphql';
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import listen from '../boot/server/listen';
+import { createExtension, createGraphqlServer } from './graphql';
+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 = `
+  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 app = express();
+  app.use(
+    '/graphql',
+    graphqlHTTP({
+      schema: makeExecutableSchema({
+        typeDefs,
+        resolvers
+      })
+    })
+  );
+
+  const { port, close } = await listen({ app, port: 0 });
+  const query = createGraphqlClient(port);
+
+  return { port, close, query };
+}
+
+async function createLocalServer({ targetPort }) {
+  const graphqlServer = await createGraphqlServer({
+    extensions: [
+      createExtension({
+        endpoint: `http://localhost:${targetPort}/graphql`,
+        getHeaders: () => ({
+          'Content-Type': 'application/json'
+        })
+      })
+    ]
+  });
+
+  const app = express();
+  app.use('/graphql', graphqlServer);
+
+  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.only('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/server/index.d.ts

@@ -1,2 +1,2 @@
-export { createApp } from '../boot/server';
-export { createExtension, storeapiExtension } from './graphql';
+export { createApp } from '../boot/server';
+export { createExtension, storeapiExtension } from './graphql';

package/server/index.js

@@ -1,3 +1,3 @@
-export { createApp } from '../boot/server';
-export { createExtension, storeapiExtension } from './graphql';
+export { createApp } from '../boot/server';
+export { createExtension, storeapiExtension } from './graphql';
 //# sourceMappingURL=index.js.map

package/server/tracking/facebook.d.ts

@@ -1,5 +1,5 @@
-import { ServerTracker } from './types';
-export default function createFacebookTracker(config?: {
-    pixelId: string;
-    token: string;
-}): ServerTracker;
+import { ServerTracker } from './types';
+export default function createFacebookTracker(config?: {
+    pixelId: string;
+    token: string;
+}): ServerTracker;

package/server/tracking/facebook.js

@@ -1,133 +1,133 @@
-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 fetch from 'node-fetch';
-import requestIp from 'request-ip';
-function getUserData(req) {
-    return {
-        client_ip_address: req.header('true-client-ip') || requestIp.getClientIp(req),
-        client_user_agent: req.headers['user-agent'],
-        fbc: req.universalCookies.get('_fbc') || '',
-        fbp: req.universalCookies.get('_fbp') || '',
-        country: req.header('x-geoip-country')
-    };
-}
-function createTrackFacebookEvent({ pixelId, token }) {
-    return function trackFacebookEvent(data, channelPixelId, channelToken) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield fetch(`https://graph.facebook.com/v13.0/${channelPixelId || pixelId}/events?access_token=${channelToken || token}`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify({
-                    data: [data]
-                })
-            });
-            return response;
-        });
-    };
-}
-export default function createFacebookTracker(config) {
-    const trackFacebookEvent = createTrackFacebookEvent(config);
-    const track = (event, data, request) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        try {
-            const user_data = getUserData(request);
-            const event_time = Math.floor(Date.now() / 1000) - 60 * 5; // subtract 5 minutes to account for time difference between server and client
-            const useArticleNumberAsId = data.useArticleNumberAsId;
-            const defaults = {
-                user_data,
-                event_time,
-                action_source: 'website',
-                event_source_url: data.location,
-                event_id: data.eventId
-            };
-            switch (event) {
-                case 'trackProduct':
-                    const productData = data.props;
-                    if (productData.action === 'add') {
-                        return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'AddToCart', custom_data: {
-                                contents: [
-                                    {
-                                        id: useArticleNumberAsId
-                                            ? productData.product.articleNumber
-                                            : productData.product.id.toString(),
-                                        quantity: productData.quantity,
-                                        item_price: (_a = productData.product.price) === null || _a === void 0 ? void 0 : _a.incVat
-                                    }
-                                ],
-                                content_name: productData.product.name,
-                                content_type: 'product',
-                                currency: data.currency,
-                                value: (_b = productData.product.price) === null || _b === void 0 ? void 0 : _b.incVat
-                            } }), data.pixelId, data.token);
-                    }
-                    else if (productData.action === 'view') {
-                        return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'ViewContent', custom_data: {
-                                contents: [
-                                    {
-                                        id: useArticleNumberAsId
-                                            ? productData.product.articleNumber
-                                            : productData.product.id.toString(),
-                                        quantity: productData.quantity,
-                                        item_price: (_c = productData.product.price) === null || _c === void 0 ? void 0 : _c.incVat
-                                    }
-                                ],
-                                content_name: productData.product.name,
-                                content_type: 'product',
-                                currency: data.currency,
-                                value: (_d = productData.product.price) === null || _d === void 0 ? void 0 : _d.incVat
-                            } }), data.pixelId, data.token);
-                    }
-                    break;
-                case 'trackAddToWishList':
-                    const wishListData = data.props;
-                    return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'AddToWishlist', custom_data: {
-                            content_name: wishListData.productName,
-                            content_category: data.context.list || '',
-                            content_ids: [wishListData.articleNumber],
-                            currency: data.currency
-                        } }), data.pixelId, data.token);
-                case 'trackRegister':
-                    return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'CompleteRegistration', custom_data: {} }), data.pixelId, data.token);
-                case 'trackCartCheckout':
-                    const checkoutData = data.props;
-                    return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'InitiateCheckout', custom_data: {
-                            content_ids: checkoutData.cart.items.map((item) => useArticleNumberAsId ? item.articleNumber : item.id.toString()),
-                            contents: checkoutData.cart.items.map((item) => {
-                                var _a;
-                                return {
-                                    id: useArticleNumberAsId
-                                        ? item.articleNumber
-                                        : item.id.toString(),
-                                    quantity: item.quantity,
-                                    item_price: (_a = item.product.price) === null || _a === void 0 ? void 0 : _a.incVat
-                                };
-                            }),
-                            currency: data.currency,
-                            num_items: checkoutData.cart.totalQuantity,
-                            value: checkoutData.cart.productTotal.incVat
-                        } }), data.pixelId, data.token);
-                case 'trackPageView':
-                    const pageViewData = data.props;
-                    return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'PageView', custom_data: {
-                            content_name: pageViewData.title,
-                            currency: data.currency
-                        } }), data.pixelId, data.token);
-            }
-        }
-        catch (error) {
-            console.log(error);
-            return error;
-        }
-    });
-    return track;
-}
+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 fetch from 'node-fetch';
+import requestIp from 'request-ip';
+function getUserData(req) {
+    return {
+        client_ip_address: req.header('true-client-ip') || requestIp.getClientIp(req),
+        client_user_agent: req.headers['user-agent'],
+        fbc: req.universalCookies.get('_fbc') || '',
+        fbp: req.universalCookies.get('_fbp') || '',
+        country: req.header('x-geoip-country')
+    };
+}
+function createTrackFacebookEvent({ pixelId, token }) {
+    return function trackFacebookEvent(data, channelPixelId, channelToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield fetch(`https://graph.facebook.com/v13.0/${channelPixelId || pixelId}/events?access_token=${channelToken || token}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    data: [data]
+                })
+            });
+            return response;
+        });
+    };
+}
+export default function createFacebookTracker(config) {
+    const trackFacebookEvent = createTrackFacebookEvent(config);
+    const track = (event, data, request) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        try {
+            const user_data = getUserData(request);
+            const event_time = Math.floor(Date.now() / 1000) - 60 * 5; // subtract 5 minutes to account for time difference between server and client
+            const useArticleNumberAsId = data.useArticleNumberAsId;
+            const defaults = {
+                user_data,
+                event_time,
+                action_source: 'website',
+                event_source_url: data.location,
+                event_id: data.eventId
+            };
+            switch (event) {
+                case 'trackProduct':
+                    const productData = data.props;
+                    if (productData.action === 'add') {
+                        return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'AddToCart', custom_data: {
+                                contents: [
+                                    {
+                                        id: useArticleNumberAsId
+                                            ? productData.product.articleNumber
+                                            : productData.product.id.toString(),
+                                        quantity: productData.quantity,
+                                        item_price: (_a = productData.product.price) === null || _a === void 0 ? void 0 : _a.incVat
+                                    }
+                                ],
+                                content_name: productData.product.name,
+                                content_type: 'product',
+                                currency: data.currency,
+                                value: (_b = productData.product.price) === null || _b === void 0 ? void 0 : _b.incVat
+                            } }), data.pixelId, data.token);
+                    }
+                    else if (productData.action === 'view') {
+                        return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'ViewContent', custom_data: {
+                                contents: [
+                                    {
+                                        id: useArticleNumberAsId
+                                            ? productData.product.articleNumber
+                                            : productData.product.id.toString(),
+                                        quantity: productData.quantity,
+                                        item_price: (_c = productData.product.price) === null || _c === void 0 ? void 0 : _c.incVat
+                                    }
+                                ],
+                                content_name: productData.product.name,
+                                content_type: 'product',
+                                currency: data.currency,
+                                value: (_d = productData.product.price) === null || _d === void 0 ? void 0 : _d.incVat
+                            } }), data.pixelId, data.token);
+                    }
+                    break;
+                case 'trackAddToWishList':
+                    const wishListData = data.props;
+                    return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'AddToWishlist', custom_data: {
+                            content_name: wishListData.productName,
+                            content_category: data.context.list || '',
+                            content_ids: [wishListData.articleNumber],
+                            currency: data.currency
+                        } }), data.pixelId, data.token);
+                case 'trackRegister':
+                    return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'CompleteRegistration', custom_data: {} }), data.pixelId, data.token);
+                case 'trackCartCheckout':
+                    const checkoutData = data.props;
+                    return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'InitiateCheckout', custom_data: {
+                            content_ids: checkoutData.cart.items.map((item) => useArticleNumberAsId ? item.articleNumber : item.id.toString()),
+                            contents: checkoutData.cart.items.map((item) => {
+                                var _a;
+                                return {
+                                    id: useArticleNumberAsId
+                                        ? item.articleNumber
+                                        : item.id.toString(),
+                                    quantity: item.quantity,
+                                    item_price: (_a = item.product.price) === null || _a === void 0 ? void 0 : _a.incVat
+                                };
+                            }),
+                            currency: data.currency,
+                            num_items: checkoutData.cart.totalQuantity,
+                            value: checkoutData.cart.productTotal.incVat
+                        } }), data.pixelId, data.token);
+                case 'trackPageView':
+                    const pageViewData = data.props;
+                    return yield trackFacebookEvent(Object.assign(Object.assign({}, defaults), { event_name: 'PageView', custom_data: {
+                            content_name: pageViewData.title,
+                            currency: data.currency
+                        } }), data.pixelId, data.token);
+            }
+        }
+        catch (error) {
+            console.log(error);
+            return error;
+        }
+    });
+    return track;
+}
 //# sourceMappingURL=facebook.js.map

package/server/tracking/middleware.d.ts

@@ -1,8 +1,8 @@
-import { Response, Request } from 'express';
-import { Cookies } from 'react-cookie';
-import { ServerTracker } from './types';
-declare function trackingMiddleware(trackers: ServerTracker[]): (req: Request & {
-    universalCookies: Cookies;
-    breakpoint: string;
-}, res: Response) => void;
-export default trackingMiddleware;
+import { Response, Request } from 'express';
+import { Cookies } from 'react-cookie';
+import { ServerTracker } from './types';
+declare function trackingMiddleware(trackers: ServerTracker[]): (req: Request & {
+    universalCookies: Cookies;
+    breakpoint: string;
+}, res: Response) => void;
+export default trackingMiddleware;

package/server/tracking/middleware.js

@@ -1,15 +1,15 @@
-function trackingMiddleware(trackers) {
-    return (req, res) => {
-        try {
-            const event = req.query.event;
-            const data = req.body;
-            trackers.forEach((track) => track(event, data, req));
-            res.status(200).end();
-        }
-        catch (e) {
-            res.status(400).end();
-        }
-    };
-}
-export default trackingMiddleware;
+function trackingMiddleware(trackers) {
+    return (req, res) => {
+        try {
+            const event = req.query.event;
+            const data = req.body;
+            trackers.forEach((track) => track(event, data, req));
+            res.status(200).end();
+        }
+        catch (e) {
+            res.status(400).end();
+        }
+    };
+}
+export default trackingMiddleware;
 //# sourceMappingURL=middleware.js.map

package/server/tracking/types.d.ts

@@ -1,33 +1,33 @@
-import { Request } from 'express';
-import {
-  BaseTrackingEvents,
-  TrackingFunctionContext,
-  TrackingProps
-} from '@jetshop/core/analytics/trackerRegistry';
-
-interface Item {
-  id: string; // SKU
-  quantity: number;
-}
-
-export interface AddToCart {
-  name: string;
-  items: Item[];
-  currency: string;
-  value: number;
-}
-
-export type ServerTracker = (
-  event: keyof BaseTrackingEvents,
-  data: {
-    props: TrackingProps[keyof BaseTrackingEvents];
-    currency: string;
-    useArticleNumberAsId: boolean;
-    context: TrackingFunctionContext;
-    location: string;
-    eventId: string;
-    pixelId?: string;
-    token?: string;
-  },
-  req: Request & { universalCookies: Cookies; breakpoint: string }
-) => void;
+import { Request } from 'express';
+import {
+  BaseTrackingEvents,
+  TrackingFunctionContext,
+  TrackingProps
+} from '@jetshop/core/analytics/trackerRegistry';
+
+interface Item {
+  id: string; // SKU
+  quantity: number;
+}
+
+export interface AddToCart {
+  name: string;
+  items: Item[];
+  currency: string;
+  value: number;
+}
+
+export type ServerTracker = (
+  event: keyof BaseTrackingEvents,
+  data: {
+    props: TrackingProps[keyof BaseTrackingEvents];
+    currency: string;
+    useArticleNumberAsId: boolean;
+    context: TrackingFunctionContext;
+    location: string;
+    eventId: string;
+    pixelId?: string;
+    token?: string;
+  },
+  req: Request & { universalCookies: Cookies; breakpoint: string }
+) => void;

package/setupTests.js

@@ -1,2 +1,2 @@
-// add some helpful assertions
-import 'jest-dom/extend-expect';
+// add some helpful assertions
+import 'jest-dom/extend-expect';