@prg/gatsby-source-something-whatever/nodes.js

something something whatever who gives a crap.

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

exports.__esModule = true;
exports.createContentNodes = void 0;

var _pluralize = _interopRequireDefault(require("pluralize"));

var _lodash = _interopRequireDefault(require("lodash.camelcase"));

var _gatsbyNodeHelpers = _interopRequireDefault(require("gatsby-node-helpers"));

var _util = require("./util");

var _constants = require("./constants");

var _queries = require("./queries");

const {
  createNodeFactory
} = (0, _gatsbyNodeHelpers.default)({
  typePrefix: _constants.TYPE_PREFIX,
  conflictFieldPrefix: 'platform'
});

const byPosition = ({
  position: positionA
}, {
  position: positionB
}) => positionA - positionB;

const byId = TYPE => ({
  id
}) => (0, _util.convertId)(id, TYPE);

const getSelectedOptions = variant => variant.selectedOptions.reduce((acc, {
  title,
  value
}) => Object.assign({}, acc, {
  [title]: value
}), {});

const productMiddleware = node => {
  const {
    id,
    available,
    title,
    handle,
    description,
    type,
    parent,
    children,
    internal
  } = node;
  const foreignIds = node.shopifyProductIds.map(({
    id
  }) => id);
  const metadata = node.metadata === null ? {} : node.metadata;
  const images = node.images.map(byId(_constants.IMAGE));
  const options = node.options.sort(byPosition).map(byId(_constants.PRODUCT_OPTION));
  const optionValues = node.options.reduce((acc, {
    title,
    values
  }) => Object.assign({}, acc, {
    [title]: values.sort(byPosition).map(value => value.title)
  }), {});
  const variants = node.variants.sort((a, b) => {
    try {
      const A = getSelectedOptions(a);
      const B = getSelectedOptions(b);

      if (A.Color === B.Color && A.Size !== B.Size) {
        return optionValues.Size.indexOf(A.Size) - optionValues.Size.indexOf(B.Size);
      }

      return optionValues.Color.indexOf(A.Color) - optionValues.Color.indexOf(B.Color);
    } catch (error) {
      return 0;
    }
  });
  const featuredImage = variants[0].images.length ? (0, _util.convertId)(variants[0].images[0].id, _constants.IMAGE) : images[0];
  return {
    id,
    available,
    title,
    handle,
    description,
    type,
    foreignIds,
    metadata,
    featuredImage___NODE: featuredImage,
    options___NODE: options,
    images___NODE: images,
    optionValues,
    variants___NODE: variants.map(({
      id
    }) => (0, _util.convertId)(id, _constants.PRODUCT_VARIANT)),
    parent,
    children,
    internal
  };
};

const productVariantMiddleware = node => {
  const {
    id,
    title,
    available,
    inventory,
    foreignId,
    productForeignId,
    foreignProductHandle,
    foreignProductPublishedAt,
    price,
    compareAtPrice,
    metadata,
    parent,
    children,
    internal
  } = node;
  const productId = (0, _util.convertId)(node.productId, _constants.PRODUCT);
  const product = productId;
  const selectedOptions = getSelectedOptions(node);
  const firstImage = node.images.find(({
    position
  }) => position === 1);
  const secondImage = node.images.find(({
    position
  }) => position === 2);
  const image = firstImage ? (0, _util.convertId)(firstImage.id, _constants.IMAGE) : null;
  const hoverImage = secondImage ? (0, _util.convertId)(secondImage.id, _constants.IMAGE) : null;
  const images = node.images.map(byId(_constants.IMAGE));
  return {
    id,
    title,
    available,
    inventory,
    foreignId,
    productForeignId,
    foreignProductHandle,
    foreignProductPublishedAt,
    price,
    compareAtPrice,
    product___NODE: product,
    productId,
    images___NODE: images,
    image___NODE: image,
    hoverImage___NODE: hoverImage,
    selectedOptions,
    metadata,
    parent,
    children,
    internal
  };
};

const imageMiddleware = node => {
  const {
    id,
    src,
    altText,
    parent,
    children,
    internal
  } = node;

  if (node.variants && node.variants.length) {
    const {
      variant: firstVariant
    } = node.variants && node.variants[0];
    const match = firstVariant.images.find(({
      id
    }) => id === node.platformId) || {};
    const position = match.position || null;
    const product = (0, _util.convertId)(firstVariant.productId, _constants.PRODUCT);
    const variants = node.variants.map(({
      id
    }) => (0, _util.convertId)(id, _constants.PRODUCT_VARIANT));
    return {
      id,
      src,
      altText,
      position,
      product___NODE: product,
      variants___NODE: variants,
      parent,
      children,
      internal
    };
  }

  if (node.product) {
    return {
      id,
      src,
      altText,
      position: node.product.position || null,
      product___NODE: (0, _util.convertId)(node.product.id, _constants.PRODUCT),
      variants___NODE: [],
      parent,
      children,
      internal
    };
  }

  return {
    id,
    src,
    altText,
    position: null,
    product___NODE: null,
    variants___NODE: [],
    parent,
    children,
    internal
  };
};

const optionMiddleware = node => {
  const productId = (0, _util.convertId)(node.productId, _constants.PRODUCT);
  const product = productId;
  const values = node.values.sort(byPosition).map(byId(_constants.PRODUCT_OPTION_VALUE));
  return Object.assign({}, node, {
    productId,
    product___NODE: product,
    values
  });
};

const types = [{
  name: _constants.IMAGE,
  query: _queries.IMAGES_QUERY,
  middleware: imageMiddleware
}, {
  name: _constants.PRODUCT,
  query: _queries.PRODUCTS_QUERY,
  middleware: productMiddleware
}, {
  name: _constants.PRODUCT_VARIANT,
  query: _queries.PRODUCT_VARIANTS_QUERY,
  middleware: productVariantMiddleware
}, {
  name: _constants.PRODUCT_OPTION,
  query: _queries.PRODUCT_OPTIONS_QUERY,
  middleware: optionMiddleware
}, {
  name: _constants.PRODUCT_OPTION_VALUE,
  query: _queries.PRODUCT_OPTION_VALUES_QUERY
}];

const getTypeData = async (types, client, shopId) => {
  const queries = types.map(({
    name,
    query,
    middleware = node => node
  }) => {
    const factory = createNodeFactory(name, middleware);
    const normalizedName = (0, _lodash.default)((0, _pluralize.default)(name));
    return client.query({
      query,
      variables: {
        shopId
      }
    }).then(({
      data
    }) => {
      return {
        name,
        nodes: data[normalizedName].map(item => factory(item))
      };
    });
  });
  const typeData = await Promise.all(queries);
  return typeData.reduce((acc, {
    name,
    nodes
  }) => Object.assign({}, acc, {
    [name]: nodes
  }), {});
};

const createContentNodes = async (client, shopId, {
  actions: {
    createNode
  }
}) => {
  try {
    const typeData = await getTypeData(types, client, shopId);
    const createdNodes = Object.entries(typeData).map(([type, nodes]) => {
      console.log((0, _util.formatMsg)(`Created ${nodes.length} ${_constants.TYPE_PREFIX}${type} nodes.`));
      return nodes.map(node => createNode(node));
    });
    await Promise.all(createdNodes);
    return typeData;
  } catch (error) {
    console.log('error', error);
  }
};

exports.createContentNodes = createContentNodes;