@foxtware/mineral 0.1.16 → 0.1.18

package/api/shopify/shopifyMetafieldDefinitionGet.js

@@ -0,0 +1,108 @@
+// https://shopify.dev/docs/api/admin-graphql/latest/queries/metafieldDefinition
+
+const { credsValidator } = require('../validators');
+const { ArgsWarden, objHasAny } = require('../utils');
+const { shopifyClient } = require('./shopify.utils');
+
+const metafieldDefinitionIdentifierValidator = (metafieldDefinitionIdentifier) => {
+  return objHasAny(metafieldDefinitionIdentifier, [
+    'ownerType',
+    'namespace',
+    'key',
+  ]);
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['metafieldDefinitionIdentifier', metafieldDefinitionIdentifierValidator],
+]);
+
+const defaultAttrs = `
+  name
+  namespace
+  key
+  description
+  ownerType
+  pinnedPosition
+  type {
+    name
+  }
+  validations {
+    name
+    value
+  }
+  capabilities {
+    adminFilterable {
+      enabled
+    }
+    smartCollectionCondition {
+      enabled
+    }
+    uniqueValues {
+      enabled
+    }
+  }
+`.trim();
+
+const shopifyMetafieldDefinitionGet = async (
+  credsPayload,
+  metafieldDefinitionIdentifier,
+  {
+    apiVersion,
+    attrs = defaultAttrs,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    metafieldDefinitionIdentifier,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return shopifyClient.fetch({
+    requestPayload: {
+      method: 'post',
+      body: {
+        query: `
+          query GetMetafieldDefinition($identifier: MetafieldDefinitionIdentifierInput!) {
+            metafieldDefinition(identifier: $identifier) {
+              ${ attrs }
+            }
+          }
+        `,
+        variables: {
+          identifier: metafieldDefinitionIdentifier,
+        },
+      },
+    },
+    context: {
+      credsPayload,
+      apiVersion,
+      resultPath: 'data.metafieldDefinition',
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  shopifyMetafieldDefinitionGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/shopifyMetafieldDefinitionGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "shopify.au" },
+    "metafieldDefinitionIdentifier": {
+      "ownerType": "PRODUCT",
+      "namespace": "custom",
+      "key": "outfit_builder_image"
+    }
+  }'
+*/

package/api/shopify/shopifyMetafieldDefinitionPropagate.js

@@ -0,0 +1,167 @@
+// https://shopify.dev/docs/api/admin-graphql/latest/mutations/metafieldDefinitionCreate
+// https://shopify.dev/docs/api/admin-graphql/latest/queries/metafieldDefinition
+
+const { credsValidator } = require('../validators');
+const { ArgsWarden, objHasAny } = require('../utils');
+const { shopifyMetafieldDefinitionGet } = require('./shopifyMetafieldDefinitionGet');
+const { shopifyMetafieldDefinitionCreate } = require('./shopifyMetafieldDefinitionCreate');
+
+const defaultReturnCreatedDefinitionAttrs = 'id name namespace key ownerType type { name }';
+
+const metafieldDefinitionIdentifierValidator = (metafieldDefinitionIdentifier) => {
+  return objHasAny(metafieldDefinitionIdentifier, [
+    'ownerType',
+    'namespace',
+    'key',
+  ]);
+};
+
+const argsWarden = new ArgsWarden([
+  ['fromStoreCredsPayload', credsValidator],
+  ['toStoreCredsPayload', credsValidator],
+  ['metafieldDefinitionIdentifier', metafieldDefinitionIdentifierValidator],
+]);
+
+const metafieldDefinitionInputFromDefinition = (sourceDefinition) => {
+  const {
+    name,
+    namespace,
+    key,
+    description,
+    ownerType,
+    type,
+    validations,
+    capabilities,
+    pinnedPosition,
+  } = sourceDefinition;
+
+  const definitionInput = {
+    name,
+    namespace,
+    key,
+    ownerType,
+    type: type?.name,
+    ...(description && { description }),
+    ...(pinnedPosition != null && { pin: true }),
+  };
+
+  if (Array.isArray(validations) && validations.length) {
+    definitionInput.validations = validations.map(({ name: validationName, value }) => ({
+      name: validationName,
+      value,
+    }));
+  }
+
+  if (capabilities) {
+    definitionInput.capabilities = {
+      ...(capabilities.adminFilterable && {
+        adminFilterable: { enabled: capabilities.adminFilterable.enabled },
+      }),
+      ...(capabilities.smartCollectionCondition && {
+        smartCollectionCondition: { enabled: capabilities.smartCollectionCondition.enabled },
+      }),
+      ...(capabilities.uniqueValues && {
+        uniqueValues: { enabled: capabilities.uniqueValues.enabled },
+      }),
+    };
+  }
+
+  return definitionInput;
+};
+
+const shopifyMetafieldDefinitionPropagate = async (
+  fromStoreCredsPayload,
+  toStoreCredsPayload,
+  metafieldDefinitionIdentifier,
+  {
+    apiVersion,
+    returnCreatedDefinitionAttrs = defaultReturnCreatedDefinitionAttrs,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    fromStoreCredsPayload,
+    toStoreCredsPayload,
+    metafieldDefinitionIdentifier,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const sourceResponse = await shopifyMetafieldDefinitionGet(
+    fromStoreCredsPayload,
+    metafieldDefinitionIdentifier,
+    { apiVersion },
+  );
+
+  if (!sourceResponse.ok) {
+    return sourceResponse;
+  }
+
+  if (!sourceResponse.data) {
+    return {
+      ok: false,
+      error: {
+        code: 'NOT_FOUND',
+        message: 'Metafield definition not found on source store.',
+        details: metafieldDefinitionIdentifier,
+      },
+    };
+  }
+
+  const definitionInput = metafieldDefinitionInputFromDefinition(sourceResponse.data);
+
+  const {
+    ownerType,
+    namespace,
+    key,
+    name,
+    type,
+    description,
+    pin,
+    validations,
+    capabilities,
+  } = definitionInput;
+
+  return shopifyMetafieldDefinitionCreate(
+    toStoreCredsPayload,
+    ownerType,
+    namespace,
+    key,
+    name,
+    type,
+    {
+      apiVersion,
+      ...(description && { description }),
+      ...(pin != null && { pin }),
+      ...(validations && { validations }),
+      ...(capabilities && { capabilities }),
+      returnSchema: `
+        createdDefinition { ${ returnCreatedDefinitionAttrs } }
+      `.trim(),
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  shopifyMetafieldDefinitionPropagate,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/shopifyMetafieldDefinitionPropagate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "fromStoreCredsPayload": { "credsPath": "shopify.au" },
+    "toStoreCredsPayload": { "credsPath": "shopify.us" },
+    "metafieldDefinitionIdentifier": {
+      "ownerType": "PRODUCT",
+      "namespace": "custom",
+      "key": "outfit_builder_image"
+    }
+  }'
+*/

package/api/shopify/shopifyThemeFileGet.js

@@ -0,0 +1,112 @@
+// https://shopify.dev/docs/api/admin-graphql/latest/queries/theme
+
+const { credsValidator } = require('../validators');
+const { ArgsWarden, ensureArray } = require('../utils');
+const { shopifyClient } = require('./shopify.utils');
+
+const defaultAttrs = `
+  filename
+  contentType
+  size
+  body {
+    ... on OnlineStoreThemeFileBodyText {
+      content
+    }
+    ... on OnlineStoreThemeFileBodyBase64 {
+      contentBase64
+    }
+    ... on OnlineStoreThemeFileBodyUrl {
+      url
+    }
+  }
+`.trim();
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['themeId'],
+  ['filenames'],
+]);
+
+const shopifyThemeFileGet = async (
+  credsPayload,
+  themeId,
+  filenames,
+  {
+    apiVersion,
+    attrs = defaultAttrs,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    themeId,
+    filenames,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const filenamesList = ensureArray(filenames);
+
+  const response = await shopifyClient.fetch({
+    requestPayload: {
+      method: 'post',
+      body: {
+        query: `
+          query ThemeFiles($themeId: ID!, $filenames: [String!]!) {
+            theme(id: $themeId) {
+              files(filenames: $filenames) {
+                nodes {
+                  ${ attrs }
+                }
+                userErrors {
+                  code
+                  filename
+                }
+              }
+            }
+          }
+        `,
+        variables: {
+          themeId: `gid://shopify/OnlineStoreTheme/${ themeId }`,
+          filenames: filenamesList,
+        },
+      },
+    },
+    context: {
+      credsPayload,
+      apiVersion,
+      resultPath: 'data.theme.files',
+    },
+  });
+
+  if (!response.ok) {
+    return response;
+  }
+
+  // stripEdgesAndNodes turns files.nodes into an array (userErrors on the
+  // connection are dropped by the shared Shopify client pipeline).
+  return {
+    ok: true,
+    data: ensureArray(response.data),
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  shopifyThemeFileGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/shopifyThemeFileGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "shopify.au" },
+    "themeId": "129840808008",
+    "filenames": "templates/page.sign_up_beauty.json"
+  }'
+*/