@foxtware/mineral 0.1.16 → 0.1.18

package/api/shopify/shopifyThemeFilePropagate.js

@@ -0,0 +1,410 @@
+// https://shopify.dev/docs/api/admin-graphql/latest/queries/theme
+// https://shopify.dev/docs/api/admin-graphql/latest/mutations/themeFilesUpsert
+// https://shopify.dev/docs/api/admin-graphql/latest/mutations/fileCreate
+
+const { credsValidator } = require('../validators');
+const { ArgsWarden, wait } = require('../utils');
+const { shopifyThemeFileGet } = require('./shopifyThemeFileGet');
+const { shopifyThemeFilesUpsert } = require('./shopifyThemeFilesUpsert');
+const { shopifyFilesGet } = require('./shopifyFilesGet');
+const { shopifyFileCreate } = require('./shopifyFileCreate');
+
+const argsWarden = new ArgsWarden([
+  ['fromCredsPayload', credsValidator],
+  ['toCredsPayload', credsValidator],
+  ['fromThemeId'],
+  ['toThemeId'],
+  ['filepath'],
+]);
+
+const fileLookupAttrs = `
+  id
+  alt
+  fileStatus
+  preview {
+    image {
+      url
+    }
+  }
+  ... on MediaImage {
+    image {
+      url
+    }
+  }
+  ... on GenericFile {
+    url
+  }
+  ... on Video {
+    originalSource {
+      url
+    }
+  }
+`.trim();
+
+const ASSET_LINK_REGEX = /shopify:\/\/shop_(?:images|videos|files)\/[^"'\\\s]+|https?:\/\/cdn\.shopify\.com\/[^"'\\\s]+/g;
+
+const themeFileTextContent = (themeFile) => {
+  const body = themeFile?.body;
+  if (!body) {
+    return null;
+  }
+  if (body.content != null) {
+    return body.content;
+  }
+  if (body.contentBase64 != null) {
+    return Buffer.from(body.contentBase64, 'base64').toString('utf8');
+  }
+  return null;
+};
+
+const filenameFromAssetLink = (assetLink) => {
+  const withoutQuery = assetLink.split('?')[0];
+  return decodeURIComponent(withoutQuery.split('/').pop());
+};
+
+const schemeFromAssetLink = (assetLink) => {
+  const shopifySchemeMatch = assetLink.match(/^shopify:\/\/(shop_(?:images|videos|files))\//);
+  if (shopifySchemeMatch) {
+    return shopifySchemeMatch[1];
+  }
+
+  const filename = filenameFromAssetLink(assetLink).toLowerCase();
+  if (/\.(mp4|mov|webm|m4v)$/.test(filename)) {
+    return 'shop_videos';
+  }
+  if (/\.(pdf|txt|csv|json|zip|xml)$/.test(filename)) {
+    return 'shop_files';
+  }
+  return 'shop_images';
+};
+
+const shopifyAssetUrl = (scheme, filename) => `shopify://${ scheme }/${ filename }`;
+
+const fileSourceUrl = (file) => (
+  file?.image?.url
+  || file?.url
+  || file?.originalSource?.url
+  || file?.preview?.image?.url
+  || null
+);
+
+const destinationUrlForAsset = (assetLink, filename, file) => {
+  if (assetLink.startsWith('shopify://')) {
+    return shopifyAssetUrl(schemeFromAssetLink(assetLink), filename);
+  }
+
+  return fileSourceUrl(file) || shopifyAssetUrl(schemeFromAssetLink(assetLink), filename);
+};
+
+const findFileByFilename = async (
+  credsPayload,
+  filename,
+  {
+    apiVersion,
+  } = {},
+) => {
+  const response = await shopifyFilesGet(credsPayload, {
+    apiVersion,
+    attrs: fileLookupAttrs,
+    queries: [`filename:"${ filename }"`],
+    limit: 10,
+  });
+
+  if (!response.ok) {
+    return response;
+  }
+
+  const files = response.data || [];
+  const exactMatch = files.find((file) => {
+    const sourceUrl = fileSourceUrl(file);
+    if (!sourceUrl) {
+      return false;
+    }
+    return filenameFromAssetLink(sourceUrl) === filename;
+  });
+
+  return {
+    ok: true,
+    data: exactMatch || files[0] || null,
+  };
+};
+
+const waitForFileReady = async (
+  credsPayload,
+  filename,
+  {
+    apiVersion,
+    attempts = 8,
+    intervalMs = 1500,
+  } = {},
+) => {
+  let file = null;
+
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    if (attempt > 0) {
+      await wait(intervalMs);
+    }
+
+    const lookupResponse = await findFileByFilename(credsPayload, filename, { apiVersion });
+    if (!lookupResponse.ok) {
+      return lookupResponse;
+    }
+
+    file = lookupResponse.data;
+    if (file?.fileStatus === 'READY' && fileSourceUrl(file)) {
+      return {
+        ok: true,
+        data: file,
+      };
+    }
+
+    if (file?.fileStatus === 'FAILED') {
+      return {
+        ok: false,
+        error: {
+          code: 'FILE_PROCESSING_FAILED',
+          message: `Uploaded file "${ filename }" failed processing.`,
+          details: file,
+        },
+      };
+    }
+  }
+
+  return {
+    ok: true,
+    data: file,
+  };
+};
+
+const resolveAssetOnToStore = async (
+  fromCredsPayload,
+  toCredsPayload,
+  assetLink,
+  {
+    apiVersion,
+  } = {},
+) => {
+  const filename = filenameFromAssetLink(assetLink);
+
+  const toFileResponse = await findFileByFilename(toCredsPayload, filename, { apiVersion });
+  if (!toFileResponse.ok) {
+    return toFileResponse;
+  }
+
+  if (toFileResponse.data) {
+    return {
+      ok: true,
+      data: {
+        fromUrl: assetLink,
+        toUrl: destinationUrlForAsset(assetLink, filename, toFileResponse.data),
+        filename,
+        uploaded: false,
+        file: toFileResponse.data,
+      },
+    };
+  }
+
+  let originalSource = assetLink.startsWith('http') ? assetLink : null;
+
+  if (!originalSource) {
+    const fromFileResponse = await findFileByFilename(fromCredsPayload, filename, { apiVersion });
+    if (!fromFileResponse.ok) {
+      return fromFileResponse;
+    }
+    if (!fromFileResponse.data) {
+      return {
+        ok: false,
+        error: {
+          code: 'ASSET_NOT_FOUND',
+          message: `Asset "${ filename }" not found in Files on the from store.`,
+          details: { assetLink, filename },
+        },
+      };
+    }
+    originalSource = fileSourceUrl(fromFileResponse.data);
+    if (!originalSource) {
+      return {
+        ok: false,
+        error: {
+          code: 'ASSET_URL_MISSING',
+          message: `No downloadable URL for asset "${ filename }" on the from store.`,
+          details: { assetLink, filename, file: fromFileResponse.data },
+        },
+      };
+    }
+  }
+
+  const createResponse = await shopifyFileCreate(
+    toCredsPayload,
+    {
+      filename,
+      originalSource,
+    },
+    { apiVersion },
+  );
+
+  if (!createResponse.ok) {
+    return createResponse;
+  }
+
+  const readyResponse = await waitForFileReady(toCredsPayload, filename, { apiVersion });
+  if (!readyResponse.ok) {
+    return readyResponse;
+  }
+
+  const createdFile = readyResponse.data
+    || (
+      Array.isArray(createResponse.data?.files)
+        ? createResponse.data.files[0]
+        : createResponse.data?.files
+    );
+
+  return {
+    ok: true,
+    data: {
+      fromUrl: assetLink,
+      toUrl: destinationUrlForAsset(assetLink, filename, createdFile),
+      filename,
+      uploaded: true,
+      originalSource,
+      file: createdFile,
+    },
+  };
+};
+
+const shopifyThemeFilePropagate = async (
+  fromCredsPayload,
+  toCredsPayload,
+  fromThemeId,
+  toThemeId,
+  filepath,
+  {
+    apiVersion,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    fromCredsPayload,
+    toCredsPayload,
+    fromThemeId,
+    toThemeId,
+    filepath,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const fromFileResponse = await shopifyThemeFileGet(
+    fromCredsPayload,
+    fromThemeId,
+    filepath,
+    { apiVersion },
+  );
+  if (!fromFileResponse.ok) {
+    return fromFileResponse;
+  }
+
+  const fromThemeFile = fromFileResponse.data.find((file) => file?.filename === filepath)
+    || fromFileResponse.data[0];
+
+  if (!fromThemeFile) {
+    return {
+      ok: false,
+      error: {
+        code: 'NOT_FOUND',
+        message: `Theme file "${ filepath }" not found on from theme.`,
+        details: { fromThemeId, filepath },
+      },
+    };
+  }
+
+  const content = themeFileTextContent(fromThemeFile);
+  if (content == null) {
+    return {
+      ok: false,
+      error: {
+        code: 'UNSUPPORTED_BODY',
+        message: `Theme file "${ filepath }" has no text body to propagate.`,
+        details: fromThemeFile,
+      },
+    };
+  }
+
+  const assetLinks = [...new Set(content.match(ASSET_LINK_REGEX) || [])];
+  const assetMappings = [];
+
+  for (const assetLink of assetLinks) {
+    const resolveResponse = await resolveAssetOnToStore(
+      fromCredsPayload,
+      toCredsPayload,
+      assetLink,
+      { apiVersion },
+    );
+    if (!resolveResponse.ok) {
+      return resolveResponse;
+    }
+    assetMappings.push(resolveResponse.data);
+  }
+
+  let translatedContent = content;
+  for (const { fromUrl, toUrl } of assetMappings) {
+    if (fromUrl === toUrl) {
+      continue;
+    }
+    translatedContent = translatedContent.split(fromUrl).join(toUrl);
+  }
+
+  const upsertResponse = await shopifyThemeFilesUpsert(
+    toCredsPayload,
+    toThemeId,
+    {
+      filename: filepath,
+      body: {
+        type: 'TEXT',
+        value: translatedContent,
+      },
+    },
+    { apiVersion },
+  );
+
+  if (!upsertResponse.ok) {
+    return upsertResponse;
+  }
+
+  return {
+    ok: true,
+    data: {
+      filepath,
+      fromThemeId,
+      toThemeId,
+      assetMappings: assetMappings.map(({ fromUrl, toUrl, filename, uploaded }) => ({
+        fromUrl,
+        toUrl,
+        filename,
+        uploaded,
+      })),
+      upsert: upsertResponse.data,
+    },
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  shopifyThemeFilePropagate,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/shopifyThemeFilePropagate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "fromCredsPayload": { "credsPath": "shopify.au" },
+    "toCredsPayload": { "credsPath": "shopify.us" },
+    "fromThemeId": "1234",
+    "toThemeId": "5678",
+    "filepath": "templates/page.sign_up_beauty.json"
+  }'
+*/

package/api/shopify/shopifyThemeFilesUpsert.js

@@ -0,0 +1,88 @@
+// https://shopify.dev/docs/api/admin-graphql/latest/mutations/themeFilesUpsert
+
+const { credsValidator } = require('../validators');
+const { ArgsWarden, ensureArray, everyIfArray } = require('../utils');
+const { shopifyMutationDo } = require('./shopifyMutationDo');
+
+const themeFileInputValidator = ({
+  filename,
+  body,
+} = {}) => Boolean(filename && body?.type && body?.value != null);
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['themeId'],
+  ['files', (files) => everyIfArray(themeFileInputValidator, files)],
+]);
+
+const shopifyThemeFilesUpsert = async (
+  credsPayload,
+  themeId,
+  files,
+  {
+    apiVersion,
+    returnSchema = `
+      upsertedThemeFiles {
+        filename
+      }
+      job {
+        id
+        done
+      }
+    `.trim(),
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    themeId,
+    files,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return shopifyMutationDo(
+    credsPayload,
+    'themeFilesUpsert',
+    {
+      mutationVariables: {
+        themeId: {
+          type: 'ID!',
+          value: `gid://shopify/OnlineStoreTheme/${ themeId }`,
+        },
+        files: {
+          type: '[OnlineStoreThemeFilesUpsertFileInput!]!',
+          value: ensureArray(files),
+        },
+      },
+      returnSchema,
+      apiVersion,
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  shopifyThemeFilesUpsert,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/shopifyThemeFilesUpsert" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "shopify.au" },
+    "themeId": "129840808008",
+    "files": {
+      "filename": "templates/index.json",
+      "body": {
+        "type": "TEXT",
+        "value": "{ \"sections\": {}, \"order\": [] }"
+      }
+    }
+  }'
+*/

package/api/starshipit/starshipit.utils.js

@@ -63,6 +63,7 @@ const starshipitClient = new FetchClient({
     'fetch',
     fetchClientCommonSteps.exitEarlyOnNotOk,
     interpretStarshipitResponse,
+    fetchClientCommonSteps.digToPath,
   ],
 });
 

package/api/starshipit/starshipitOrderGet.js

@@ -32,7 +32,7 @@ const starshipitOrderGet = async (
     orderNumber,
   } = orderIdentifier;
 
-  const response = await starshipitClient.fetch({
+  return starshipitClient.fetch({
     requestPayload: {
       url: '/orders',
       params: {
@@ -42,17 +42,9 @@ const starshipitOrderGet = async (
     },
     context: {
       credsPayload,
+      resultPath: 'order',
     },
   });
-
-  if (!response?.ok) {
-    return response;
-  }
-
-  return {
-    ...response,
-    data: response.data?.order ?? response.data,
-  };
 };
 
 const funcApiConfig = {

package/api/utils.js

@@ -22,6 +22,8 @@ const sentenceCaseString = (string) => `${ string[0].toLowerCase() }${ string.sl
 
 const normalise = (value) => (value || '').toString().trim().toLowerCase();
 
+const valueProvided = (value) => value !== undefined && value !== null;
+
 const credsByPath = (credsPath, credsObject) => {
   const pathNodes = pathAsArray(credsPath);
 
@@ -166,6 +168,10 @@ const bodyPassesThrough = (body) => {
     return true;
   }
 
+  if (Buffer.isBuffer(body)) {
+    return true;
+  }
+
   return typeof body.getHeaders === 'function';
 };
 
@@ -394,6 +400,10 @@ const stripGraphqlEdgesAndNodes = (value) => {
     return value.edges.map((edge) => stripGraphqlEdgesAndNodes(edge?.node));
   }
 
+  if (Array.isArray(value.nodes)) {
+    return value.nodes.map(stripGraphqlEdgesAndNodes);
+  }
+
   const output = {};
   for (const [key, nestedValue] of Object.entries(value)) {
     output[key] = stripGraphqlEdgesAndNodes(nestedValue);
@@ -648,14 +658,14 @@ const fetchClientCommonSteps = {
     const { resultPath } = context;
     const { data } = response;
 
-    if (!data || !resultPath) {
+    if (!valueProvided(data) || !valueProvided(resultPath)) {
       return {};
     }
 
     const resultPathNodes = pathAsArray(resultPath);
     const dataAtPath = objectDigNodeAtPath(data, resultPathNodes);
 
-    if (!dataAtPath) {
+    if (dataAtPath === undefined) {
       return {
         response: {
           ok: false,
@@ -676,8 +686,6 @@ const fetchClientCommonSteps = {
   },
 };
 
-const valueProvided = (value) => value !== undefined && value !== null;
-
 const ensureArray = (value) => {
   if (Array.isArray(value)) {
     return value;

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.18",
   "bin": {
     "mineral": "bin/mineral.js"
   },

package/server.utils.js

@@ -3,7 +3,7 @@ const { HOSTED } = require('./api/constants');
 const { StringDecoder } = require('string_decoder');
 
 const respondJson = (res, statusCode, payload) => {
-  // !HOSTED && logDeep(payload);
+  !HOSTED && logDeep(payload);
   const body = JSON.stringify(payload);
   res.writeHead(statusCode, {
     'Content-Type': 'application/json',