@foxtware/mineral 0.1.16 → 0.1.17

package/api/etsy/etsyListingInventoryUpdate.js

@@ -5,8 +5,8 @@ const { credsValidator } = require('../validators');
 const { etsyClient } = require('./etsy.utils');
 
 const updatePayloadWithListingIdValidator = (updatePayloadWithListingId) => {
-  return valueProvided(updatePayloadWithListingId?.listingId)
-    && valueProvided(updatePayloadWithListingId?.updatePayload);
+  const { listingId, ...updatePayload } = updatePayloadWithListingId;
+  return valueProvided(listingId) && Object.keys(updatePayload).length > 0;
 };
 
 const argsWarden = new ArgsWarden([
@@ -14,7 +14,7 @@ const argsWarden = new ArgsWarden([
   ['updatePayloadWithListingId', (updatePayloadWithListingId) => everyIfArray(updatePayloadWithListingIdValidator, updatePayloadWithListingId)],
 ]);
 
-const etsyListingupdatePayloadWithListingIdSingle = async (
+const etsyListingInventoryUpdateSingle = async (
   credsPayload,
   updatePayloadWithListingId,
   {
@@ -24,9 +24,9 @@ const etsyListingupdatePayloadWithListingIdSingle = async (
   } = {},
 ) => {
 
-  const { 
-    listingId, 
-    ...updatePayload 
+  const {
+    listingId,
+    ...updatePayload
   } = updatePayloadWithListingId;
 
   return fetchClient.fetch({
@@ -44,7 +44,7 @@ const etsyListingupdatePayloadWithListingIdSingle = async (
   });
 };
 
-const etsyListingupdatePayloadWithListingId = async (
+const etsyListingInventoryUpdate = async (
   credsPayload,
   updatePayloadWithListingId,
   {
@@ -65,7 +65,7 @@ const etsyListingupdatePayloadWithListingId = async (
 
   return actionSingleOrMultiple(
     updatePayloadWithListingId,
-    etsyListingupdatePayloadWithListingIdSingle,
+    etsyListingInventoryUpdateSingle,
     (updatePayloadWithListingIdItem) => ({
       args: [credsPayload, updatePayloadWithListingIdItem, { params, inspect, fetchClient }],
     }),
@@ -80,12 +80,12 @@ const funcApiConfig = {
 };
 
 module.exports = {
-  etsyListingupdatePayloadWithListingId,
+  etsyListingInventoryUpdate,
   funcApiConfig,
 };
 
 /*
-curl -X POST "http://localhost:8000/etsyListingupdatePayloadWithListingId" \
+curl -X POST "http://localhost:8000/etsyListingInventoryUpdate" \
   -H "Content-Type: application/json" \
   -d '{
     "credsPayload": {
@@ -93,7 +93,7 @@ curl -X POST "http://localhost:8000/etsyListingupdatePayloadWithListingId" \
     },
     "updatePayloadWithListingId": {
       "listingId": "1234567890",
-      "updatePayload": {}
+      "products": []
     }
   }'
 */

package/api/shopify/shopifyMetafieldDefinitionPropagate.js

@@ -0,0 +1,211 @@
+// 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, 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 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 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 (
+  fromStoreCredsPayload,
+  toStoreCredsPayload,
+  metafieldDefinitionIdentifier,
+  {
+    apiVersion,
+    returnCreatedDefinitionAttrs = defaultReturnCreatedDefinitionAttrs,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    fromStoreCredsPayload,
+    toStoreCredsPayload,
+    metafieldDefinitionIdentifier,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const sourceResponse = await fetchSourceMetafieldDefinition(
+    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);
+
+  return shopifyMutationDo(
+    toStoreCredsPayload,
+    'metafieldDefinitionCreate',
+    {
+      mutationVariables: {
+        definition: {
+          type: 'MetafieldDefinitionInput!',
+          value: definitionInput,
+        },
+      },
+      returnSchema: `
+        createdDefinition { ${ returnCreatedDefinitionAttrs } }
+      `.trim(),
+      apiVersion,
+    },
+  );
+};
+
+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/hosting/deployFromHostingYml.js

@@ -141,7 +141,7 @@ const deployFunction = async ({
   console.log(deployCommand);
 
   try {
-    await execCommand(deployCommand);
+    await execCommand(deployCommand, { interactive: true });
   } catch (error) {
     console.error(`Error deploying function ${ functionName }:`, error);
     return;
@@ -188,7 +188,7 @@ const deployFunction = async ({
       ].join(' ');
 
       console.log(schedulerCommand);
-      await execCommand(schedulerCommand);
+      await execCommand(schedulerCommand, { interactive: true });
     } catch (error) {
       console.error(`Error handling scheduler job ${ jobName }:`, error);
     }

package/hosting/execCommand.js

@@ -1,11 +1,28 @@
 const { spawn } = require('child_process');
 
-const execCommand = (command) => new Promise((resolve, reject) => {
+const execCommand = (command, { interactive = false } = {}) => new Promise((resolve, reject) => {
   const childProcess = spawn(command, [], {
-    stdio: 'pipe',
+    stdio: interactive ? 'inherit' : 'pipe',
     shell: true,
   });
 
+  if (interactive) {
+    childProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout: '', stderr: '', command });
+        return;
+      }
+
+      reject({ stdout: '', stderr: '', command, code });
+    });
+
+    childProcess.on('error', (error) => {
+      reject({ error, command });
+    });
+
+    return;
+  }
+
   let stdout = '';
   let stderr = '';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxtware/mineral",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "bin": {
     "mineral": "bin/mineral.js"
   },