@foxtware/mineral 0.1.17 → 0.1.19

package/api/shopify/shopifyFulfillmentCreate.js

@@ -0,0 +1,180 @@
+// https://shopify.dev/docs/api/admin-graphql/latest/mutations/fulfillmentCreate
+
+const { credsValidator } = require('../validators');
+const { actionSingleOrMultiple, everyIfArray, ArgsWarden, valueProvided } = require('../utils');
+const { shopifyMutationDo } = require('../shopify/shopifyMutationDo');
+
+const fulfillmentInputValidator = (fulfillmentInput) => {
+  const { lineItemsByFulfillmentOrder } = fulfillmentInput || {};
+  if (!Array.isArray(lineItemsByFulfillmentOrder) || lineItemsByFulfillmentOrder.length === 0) {
+    return false;
+  }
+
+  return lineItemsByFulfillmentOrder.every((item) => {
+    if (!item?.fulfillmentOrderId) {
+      return false;
+    }
+
+    if (item.fulfillmentOrderLineItems) {
+      return item.fulfillmentOrderLineItems.every((lineItem) => {
+        return lineItem?.id && valueProvided(lineItem?.quantity);
+      });
+    }
+
+    return true;
+  });
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['fulfillmentInput', (i) => everyIfArray(fulfillmentInputValidator, i)],
+]);
+
+const defaultReturnFulfillmentAttrs = `
+  id
+  status
+  trackingInfo {
+    number
+    company
+    url
+  }
+`.trim();
+
+const shopifyFulfillmentCreateSingle = async (
+  credsPayload,
+  fulfillmentInput,
+  {
+    apiVersion,
+    message,
+    returnFulfillmentAttrs = defaultReturnFulfillmentAttrs,
+  } = {},
+) => {
+
+  return shopifyMutationDo(
+    credsPayload,
+    'fulfillmentCreate',
+    {
+      mutationVariables: {
+        fulfillment: {
+          type: 'FulfillmentInput!',
+          value: fulfillmentInput,
+        },
+        ...(valueProvided(message) && {
+          message: {
+            type: 'String',
+            value: message,
+          },
+        }),
+      },
+      returnSchema: `
+        fulfillment { ${ returnFulfillmentAttrs } }
+      `.trim(),
+      apiVersion,
+    },
+  );
+};
+
+const shopifyFulfillmentCreate = async (
+  credsPayload,
+  fulfillmentInput,
+  {
+    queueRunOptions,
+    apiVersion,
+    message,
+    returnFulfillmentAttrs = defaultReturnFulfillmentAttrs,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    fulfillmentInput,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return actionSingleOrMultiple(
+    fulfillmentInput,
+    shopifyFulfillmentCreateSingle,
+    (fulfillmentInputItem) => ({
+      args: [
+        credsPayload,
+        fulfillmentInputItem,
+        { apiVersion, message, returnFulfillmentAttrs },
+      ],
+    }),
+    {
+      ...(queueRunOptions ? { queueRunOptions } : {}),
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  shopifyFulfillmentCreate,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/shopifyFulfillmentCreate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "shopify.au" },
+    "fulfillmentInput": {
+      "lineItemsByFulfillmentOrder": [
+        {
+          "fulfillmentOrderId": "gid://shopify/FulfillmentOrder/1234567890"
+        }
+      ],
+      "notifyCustomer": true,
+      "trackingInfo": {
+        "number": "1234567890",
+        "company": "Australia Post",
+        "url": "https://auspost.com.au/mypost/track/details/1234567890"
+      }
+    }
+  }'
+
+curl -X POST "http://localhost:8000/shopifyFulfillmentCreate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "shopify.au" },
+    "fulfillmentInput": [
+      {
+        "lineItemsByFulfillmentOrder": [
+          {
+            "fulfillmentOrderId": "gid://shopify/FulfillmentOrder/1234567890"
+          }
+        ],
+        "notifyCustomer": true,
+        "trackingInfo": {
+          "number": "1234567890",
+          "company": "Australia Post"
+        }
+      },
+      {
+        "lineItemsByFulfillmentOrder": [
+          {
+            "fulfillmentOrderId": "gid://shopify/FulfillmentOrder/0987654321",
+            "fulfillmentOrderLineItems": [
+              {
+                "id": "gid://shopify/FulfillmentOrderLineItem/9876543210",
+                "quantity": 1
+              }
+            ]
+          }
+        ],
+        "notifyCustomer": false,
+        "originAddress": {
+          "countryCode": "AU"
+        }
+      }
+    ],
+    "options": {
+      "message": "Partial fulfillment"
+    }
+  }'
+*/

package/api/shopify/shopifyFulfillmentTrackingInfoUpdate.js

@@ -0,0 +1,92 @@
+// https://shopify.dev/docs/api/admin-graphql/latest/mutations/fulfillmentTrackingInfoUpdate
+
+const { credsValidator } = require('../validators');
+const { ArgsWarden } = require('../utils');
+const { shopifyMutationDo } = require('../shopify/shopifyMutationDo');
+
+const defaultReturnSchema = `
+  fulfillment {
+    id
+    status
+    trackingInfo {
+      company
+      number
+      url
+    }
+  }
+`;
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['fulfillmentId'],
+  ['trackingInfoPayload'],
+]);
+
+const shopifyFulfillmentTrackingInfoUpdate = async (
+  credsPayload,
+  fulfillmentId,
+  trackingInfoPayload,
+  {
+    apiVersion,
+    returnSchema = defaultReturnSchema,
+    notifyCustomer = false,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    fulfillmentId,
+    trackingInfoPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return shopifyMutationDo(
+    credsPayload,
+    'fulfillmentTrackingInfoUpdate',
+    {
+      mutationVariables: {
+        fulfillmentId: {
+          type: 'ID!',
+          value: `gid://shopify/Fulfillment/${ fulfillmentId }`,
+        },
+        trackingInfoInput: {
+          type: 'FulfillmentTrackingInput!',
+          value: trackingInfoPayload,
+        },
+        ...notifyCustomer && {
+          notifyCustomer: {
+            type: 'Boolean',
+            value: notifyCustomer,
+          },
+        },
+      },
+      returnSchema,
+      apiVersion,
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  shopifyFulfillmentTrackingInfoUpdate,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/shopifyFulfillmentTrackingInfoUpdate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "shopify.au" },
+    "fulfillmentId": "104188477512",
+    "trackingInfoPayload": {
+      "company": "FastEx",
+      "number": "123456789",
+      "url": "https://track.example.com/123456789"
+    }
+  }'
+*/

package/api/shopify/shopifyMetafieldDefinitionCreate.js

@@ -39,6 +39,7 @@ const shopifyMetafieldDefinitionCreate = async (
     pin,
     useAsCollectionCondition,
     validations,
+    capabilities,
     returnSchema = defaultReturnSchema,
   } = {},
 ) => {
@@ -73,6 +74,7 @@ const shopifyMetafieldDefinitionCreate = async (
             ...(pin && { pin }),
             ...(useAsCollectionCondition && { useAsCollectionCondition }),
             ...(validations && { validations }),
+            ...(capabilities && { capabilities }),
           },
         },
       },

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

@@ -2,36 +2,9 @@
 // https://shopify.dev/docs/api/admin-graphql/latest/queries/metafieldDefinition
 
 const { credsValidator } = require('../validators');
-const { ArgsWarden, credsFromPayload, objHasAny } = require('../utils');
-const { shopifyClient } = require('./shopify.utils');
-const { shopifyMutationDo } = require('./shopifyMutationDo');
-
-const sourceMetafieldDefinitionAttrs = `
-  name
-  namespace
-  key
-  description
-  ownerType
-  pinnedPosition
-  type {
-    name
-  }
-  validations {
-    name
-    value
-  }
-  capabilities {
-    adminFilterable {
-      enabled
-    }
-    smartCollectionCondition {
-      enabled
-    }
-    uniqueValues {
-      enabled
-    }
-  }
-`.trim();
+const { ArgsWarden, actionSingleOrMultiple, everyIfArray, objHasAny } = require('../utils');
+const { shopifyMetafieldDefinitionGet } = require('./shopifyMetafieldDefinitionGet');
+const { shopifyMetafieldDefinitionCreate } = require('./shopifyMetafieldDefinitionCreate');
 
 const defaultReturnCreatedDefinitionAttrs = 'id name namespace key ownerType type { name }';
 
@@ -45,8 +18,8 @@ const metafieldDefinitionIdentifierValidator = (metafieldDefinitionIdentifier) =
 
 const argsWarden = new ArgsWarden([
   ['fromStoreCredsPayload', credsValidator],
-  ['toStoreCredsPayload', credsValidator],
-  ['metafieldDefinitionIdentifier', metafieldDefinitionIdentifierValidator],
+  ['toStoreCredsPayload', (i) => everyIfArray(credsValidator, i)],
+  ['metafieldDefinitionIdentifier', (i) => everyIfArray(metafieldDefinitionIdentifierValidator, i)],
 ]);
 
 const metafieldDefinitionInputFromDefinition = (sourceDefinition) => {
@@ -96,38 +69,7 @@ const metafieldDefinitionInputFromDefinition = (sourceDefinition) => {
   return definitionInput;
 };
 
-const fetchSourceMetafieldDefinition = async (
-  fromStoreCredsPayload,
-  metafieldDefinitionIdentifier,
-  {
-    apiVersion,
-  } = {},
-) => {
-  const creds = await credsFromPayload(fromStoreCredsPayload);
-
-  return shopifyClient.fetch({
-    method: 'post',
-    body: {
-      query: `
-        query GetMetafieldDefinition($identifier: MetafieldDefinitionIdentifierInput!) {
-          metafieldDefinition(identifier: $identifier) {
-            ${ sourceMetafieldDefinitionAttrs }
-          }
-        }
-      `,
-      variables: {
-        identifier: metafieldDefinitionIdentifier,
-      },
-    },
-    context: {
-      creds,
-      apiVersion,
-      resultPath: 'data.metafieldDefinition',
-    },
-  });
-};
-
-const shopifyMetafieldDefinitionPropagate = async (
+const shopifyMetafieldDefinitionPropagateSingle = async (
   fromStoreCredsPayload,
   toStoreCredsPayload,
   metafieldDefinitionIdentifier,
@@ -137,16 +79,7 @@ const shopifyMetafieldDefinitionPropagate = async (
   } = {},
 ) => {
 
-  const rejectResponse = await argsWarden.responseIfRejectingArgs({
-    fromStoreCredsPayload,
-    toStoreCredsPayload,
-    metafieldDefinitionIdentifier,
-  });
-  if (rejectResponse) {
-    return rejectResponse;
-  }
-
-  const sourceResponse = await fetchSourceMetafieldDefinition(
+  const sourceResponse = await shopifyMetafieldDefinitionGet(
     fromStoreCredsPayload,
     metafieldDefinitionIdentifier,
     { apiVersion },
@@ -167,22 +100,96 @@ const shopifyMetafieldDefinitionPropagate = async (
     };
   }
 
+  const existingResponse = await shopifyMetafieldDefinitionGet(
+    toStoreCredsPayload,
+    metafieldDefinitionIdentifier,
+    {
+      apiVersion,
+      attrs: returnCreatedDefinitionAttrs,
+    },
+  );
+
+  if (!existingResponse.ok) {
+    return existingResponse;
+  }
+
+  if (existingResponse.data) {
+    return {
+      ok: true,
+      data: existingResponse.data,
+      meta: {
+        alreadyExisted: true,
+      },
+    };
+  }
+
   const definitionInput = metafieldDefinitionInputFromDefinition(sourceResponse.data);
 
-  return shopifyMutationDo(
+  const {
+    ownerType,
+    namespace,
+    key,
+    name,
+    type,
+    description,
+    pin,
+    validations,
+    capabilities,
+  } = definitionInput;
+
+  return shopifyMetafieldDefinitionCreate(
     toStoreCredsPayload,
-    'metafieldDefinitionCreate',
+    ownerType,
+    namespace,
+    key,
+    name,
+    type,
     {
-      mutationVariables: {
-        definition: {
-          type: 'MetafieldDefinitionInput!',
-          value: definitionInput,
-        },
-      },
+      apiVersion,
+      ...(description && { description }),
+      ...(pin != null && { pin }),
+      ...(validations && { validations }),
+      ...(capabilities && { capabilities }),
       returnSchema: `
         createdDefinition { ${ returnCreatedDefinitionAttrs } }
       `.trim(),
-      apiVersion,
+    },
+  );
+};
+
+const shopifyMetafieldDefinitionPropagate = async (
+  fromStoreCredsPayload,
+  toStoreCredsPayload,
+  metafieldDefinitionIdentifier,
+  {
+    queueRunOptions,
+    apiVersion,
+    returnCreatedDefinitionAttrs = defaultReturnCreatedDefinitionAttrs,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    fromStoreCredsPayload,
+    toStoreCredsPayload,
+    metafieldDefinitionIdentifier,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return actionSingleOrMultiple(
+    [toStoreCredsPayload, metafieldDefinitionIdentifier],
+    shopifyMetafieldDefinitionPropagateSingle,
+    (toStoreCredsPayloadItem, metafieldDefinitionIdentifierItem) => ({
+      args: [
+        fromStoreCredsPayload,
+        toStoreCredsPayloadItem,
+        metafieldDefinitionIdentifierItem,
+        { apiVersion, returnCreatedDefinitionAttrs },
+      ],
+    }),
+    {
+      ...(queueRunOptions ? { queueRunOptions } : {}),
     },
   );
 };
@@ -201,11 +208,11 @@ curl -X POST "http://localhost:8000/shopifyMetafieldDefinitionPropagate" \
   -H "Content-Type: application/json" \
   -d '{
     "fromStoreCredsPayload": { "credsPath": "shopify.au" },
-    "toStoreCredsPayload": { "credsPath": "shopify.us" },
+    "toStoreCredsPayload": [{ "credsPath": "shopify.us" }, { "credsPath": "shopify.uk" }],
     "metafieldDefinitionIdentifier": {
       "ownerType": "PRODUCT",
-      "namespace": "custom",
-      "key": "outfit_builder_image"
+      "namespace": "merch",
+      "key": "associations"
     }
   }'
 */