@foxtware/mineral 0.1.17 → 0.1.18

package/api/backblaze/backblazeFileUpload.js

@@ -0,0 +1,142 @@
+// https://www.backblaze.com/apidocs/b2-upload-file
+
+const fs = require('fs').promises;
+const path = require('path');
+
+const { ArgsWarden, valueProvided } = require('../utils');
+const { credsValidator } = require('../validators');
+const {
+  backblazeUploadFileBytes,
+  bucketIdentifierValidator,
+  getBackblazeSession,
+  publicFileUrlForBucketName,
+  resolveBucketIdFromIdentifier,
+} = require('../backblaze/backblaze.utils');
+
+const fileDataValidator = (fileData) => {
+  const { filePath, fileName, fileSource } = fileData;
+  return valueProvided(filePath)
+    || (valueProvided(fileName) && valueProvided(fileSource))
+    ;
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['bucketIdentifier', bucketIdentifierValidator],
+  ['fileData', fileDataValidator],
+]);
+
+const backblazeFileUpload = async (
+  credsPayload,
+  bucketIdentifier,
+  fileData,
+  {
+    contentType = 'b2/x-auto',
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    bucketIdentifier,
+    fileData,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const {
+    bucketName,
+  } = bucketIdentifier;
+
+  const bucketIdResponse = await resolveBucketIdFromIdentifier(
+    credsPayload,
+    bucketIdentifier,
+  );
+  if (!bucketIdResponse.ok) {
+    return bucketIdResponse;
+  }
+
+  const { data: bucketId } = bucketIdResponse;
+
+  let {
+    filePath,
+    fileName,
+    fileSource,
+  } = fileData;
+
+  if (filePath) {
+    fileName = path.basename(filePath);
+    fileSource = await fs.readFile(filePath);
+  }
+
+  if (!(fileName && fileSource !== undefined)) {
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_FILE_DATA',
+        message: 'Provide filePath or fileName with fileSource',
+      },
+    };
+  }
+
+  const fileBytes = Buffer.isBuffer(fileSource)
+    ? fileSource
+    : Buffer.from(String(fileSource));
+
+  const uploadResponse = await backblazeUploadFileBytes({
+    credsPayload,
+    bucketId,
+    fileName,
+    fileBytes,
+    contentType,
+  });
+
+  if (!uploadResponse.ok) {
+    return uploadResponse;
+  }
+
+  let publicFileUrl;
+
+  if (bucketName) {
+    const sessionResponse = await getBackblazeSession(credsPayload);
+
+    if (sessionResponse.ok) {
+      publicFileUrl = publicFileUrlForBucketName({
+        downloadUrl: sessionResponse.data.downloadUrl,
+        bucketName,
+        fileName: uploadResponse.data?.fileName ?? fileName,
+      });
+    }
+  }
+
+  return {
+    ok: true,
+    data: {
+      ...uploadResponse.data,
+      ...publicFileUrl && {
+        customData: {
+          publicFileUrl,
+        },
+      },
+    },
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  backblazeFileUpload,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/backblazeFileUpload" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "backblaze" },
+    "bucketIdentifier": { "bucketName": "crabs" },
+    "fileData": { "fileName": "crab.txt", "fileSource": "one big claw, one small" }
+  }'
+*/

package/api/backblaze/backblazeFilesGet.js

@@ -0,0 +1,85 @@
+// https://www.backblaze.com/apidocs/b2-list-file-names
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { B2_API_VERSION_PATH } = require('../backblaze/backblaze.constants');
+const {
+  bucketIdentifierValidator,
+  resolveBucketIdFromIdentifier,
+} = require('../backblaze/backblaze.utils');
+const { backblazeGet, backblazeGetter } = require('../backblaze/backblazeGet');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['bucketIdentifier', bucketIdentifierValidator],
+]);
+
+const backblazeFilesGet = async (
+  returnGetter,
+
+  credsPayload,
+  bucketIdentifier,
+  {
+    prefix,
+    maxFileCount,
+    fetchClient,
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    bucketIdentifier,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const bucketIdResponse = await resolveBucketIdFromIdentifier(
+    credsPayload,
+    bucketIdentifier,
+    { fetchClient },
+  );
+  if (!bucketIdResponse.ok) {
+    return bucketIdResponse;
+  }
+
+  const { data: bucketId } = bucketIdResponse;
+
+  const getterArgs = [
+    credsPayload,
+    `${ B2_API_VERSION_PATH }/b2_list_file_names`,
+    {
+      params: {
+        bucketId,
+        ...prefix && { prefix },
+      },
+      ...maxFileCount && { maxFileCount },
+      ...fetchClient && { fetchClient },
+      ...getterOptions,
+    },
+  ];
+
+  return returnGetter
+    ? backblazeGetter(...getterArgs)
+    : backblazeGet(...getterArgs);
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  backblazeFilesGet: (...args) => backblazeFilesGet(false, ...args),
+  backblazeFilesGetter: (...args) => backblazeFilesGet(true, ...args),
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/backblazeFilesGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "backblaze" },
+    "bucketIdentifier": { "bucketName": "crabs" }
+  }'
+*/

package/api/backblaze/backblazeGet.js

@@ -0,0 +1,139 @@
+// https://www.backblaze.com/apidocs/b2-list-file-names
+
+const { ArgsWarden, Getter } = require('../utils');
+const { credsValidator } = require('../validators');
+const { B2_API_VERSION_PATH, MAX_FILES_PER_PAGE } = require('../backblaze/backblaze.constants');
+const { backblazeClient } = require('../backblaze/backblaze.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['url'],
+]);
+
+const backblazeGetPacket = async (
+  credsPayload,
+  url,
+  {
+    params,
+    maxFileCount = MAX_FILES_PER_PAGE,
+    fetchClient = backblazeClient,
+  } = {},
+) => {
+
+  return fetchClient.fetch({
+    requestPayload: {
+      method: 'get',
+      url,
+      params: {
+        maxFileCount,
+        ...params,
+      },
+    },
+    context: { credsPayload },
+  });
+};
+
+const backblazeGetPaginator = async (currentParams, response) => {
+  if (!response?.ok) {
+    return [true];
+  }
+
+  const { nextFileName } = response.data ?? {};
+
+  if (!nextFileName) {
+    return [true];
+  }
+
+  const { args, options } = currentParams;
+
+  return [false, {
+    args,
+    options: {
+      ...options,
+      params: {
+        ...options.params,
+        startFileName: nextFileName,
+      },
+    },
+  }];
+};
+
+const backblazeGetDigester = (response) => {
+  if (!response?.ok) {
+    return [];
+  }
+
+  return response.data?.files ?? [];
+};
+
+const backblazeGet = async (
+  returnGetter,
+
+  credsPayload,
+  url,
+  {
+    params,
+    maxFileCount = MAX_FILES_PER_PAGE,
+    fetchClient,
+    ...getterOptions
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    url,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const getter = new Getter(
+    {
+      args: [credsPayload, url],
+      options: {
+        params,
+        maxFileCount,
+        fetchClient,
+      },
+    },
+    {
+      func: backblazeGetPacket,
+      digester: backblazeGetDigester,
+      paginator: backblazeGetPaginator,
+      ...getterOptions,
+    },
+  );
+
+  if (returnGetter) {
+    return getter;
+  }
+
+  const data = await getter.run({ returnAll: true });
+
+  return {
+    ok: true,
+    data,
+  };
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  backblazeGet: (...args) => backblazeGet(false, ...args),
+  backblazeGetter: (...args) => backblazeGet(true, ...args),
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/backblazeGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "backblaze" },
+    "url": "/b2api/v2/b2_list_file_names",
+    "options": {
+      "params": { "bucketId": "REPLACE_BUCKET_ID" }
+    }
+  }'
+*/

package/api/backblaze/docs.md

@@ -0,0 +1,6 @@
+# Backblaze B2
+
+- [B2 Native API](https://www.backblaze.com/apidocs/introduction-to-the-b2-native-api)
+- [Authorize account](https://www.backblaze.com/apidocs/b2-authorize-account)
+
+REST JSON. Application keys authenticate via HTTP Basic on `b2_authorize_account` at `https://api.backblazeb2.com`; the response supplies an account-specific `apiUrl` and bearer token for other `b2_*` calls. Uploads use a dedicated upload URL and token from `b2_get_upload_url`, not the account authorization token.

package/api/etsy/etsyListingUpdate.js

@@ -39,7 +39,7 @@ const etsyListingUpdate = async (
 
   return fetchClient.fetch({
     requestPayload: {
-      method: 'patch',
+      method: 'PATCH',
       url: `/application/shops/${ shopId }/listings/${ listingId }`,
       body: updatePayload,
     },

package/api/gorgias/gorgias.constants.js

@@ -0,0 +1,8 @@
+const apiBaseUrlForDomain = (domain) => `https://${ domain }.gorgias.com/api`;
+
+const MAX_PER_PAGE = 100;
+
+module.exports = {
+  apiBaseUrlForDomain,
+  MAX_PER_PAGE,
+};

package/api/gorgias/gorgias.utils.js

@@ -0,0 +1,46 @@
+const { apiBaseUrlForDomain } = require('../gorgias/gorgias.constants');
+const { resolveCreds } = require('../pipelineSteps');
+const {
+  appendUrlToBase,
+  FetchClient,
+  fetchClientCommonSteps,
+} = require('../utils');
+
+const useUrlAndAuthHeaders = async (state) => {
+  const { requestPayload, context } = state;
+  const { creds } = context;
+  const {
+    API_KEY,
+    DOMAIN,
+    EMAIL,
+  } = creds;
+
+  const basicToken = Buffer
+    .from(`${ EMAIL }:${ API_KEY }`)
+    .toString('base64');
+
+  return {
+    requestPayload: {
+      ...requestPayload,
+      url: appendUrlToBase(apiBaseUrlForDomain(DOMAIN), requestPayload.url),
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Basic ${ basicToken }`,
+        ...requestPayload.headers,
+      },
+    },
+  };
+};
+
+const gorgiasClient = new FetchClient({
+  pipeline: [
+    resolveCreds,
+    useUrlAndAuthHeaders,
+    'fetch',
+    fetchClientCommonSteps.exitEarlyOnNotOk,
+  ],
+});
+
+module.exports = {
+  gorgiasClient,
+};

package/api/gorgias/gorgiasAccountGet.js

@@ -0,0 +1,51 @@
+// https://developers.gorgias.com/reference/get-account
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { gorgiasClient } = require('../gorgias/gorgias.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const gorgiasAccountGet = async (
+  credsPayload,
+  {
+    inspect = false,
+    fetchClient = gorgiasClient,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return fetchClient.fetch({
+    requestPayload: {
+      method: 'get',
+      url: '/account',
+    },
+    context: { credsPayload },
+    inspect,
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  gorgiasAccountGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/gorgiasAccountGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "gorgias" }
+  }'
+*/

package/api/gorgias/gorgiasCustomerGet.js

@@ -0,0 +1,70 @@
+// https://developers.gorgias.com/reference/get-customer
+
+const { ArgsWarden, actionSingleOrMultiple } = require('../utils');
+const { credsValidator } = require('../validators');
+const { gorgiasGetSingle } = require('../gorgias/gorgiasGetSingle');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['customerId'],
+]);
+
+const gorgiasCustomerGetSingle = async (
+  credsPayload,
+  customerId,
+  options = {},
+) => {
+  return gorgiasGetSingle(
+    credsPayload,
+    '/customers',
+    customerId,
+    options,
+  );
+};
+
+const gorgiasCustomerGet = async (
+  credsPayload,
+  customerId,
+  {
+    queueRunOptions,
+    ...options
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    customerId,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return actionSingleOrMultiple(
+    customerId,
+    gorgiasCustomerGetSingle,
+    (customerIdItem) => ({
+      args: [credsPayload, customerIdItem, options],
+    }),
+    {
+      ...(queueRunOptions ? { queueRunOptions } : {}),
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  gorgiasCustomerGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/gorgiasCustomerGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "gorgias" },
+    "customerId": "123456789"
+  }'
+*/

package/api/gorgias/gorgiasCustomersGet.js

@@ -0,0 +1,56 @@
+// https://developers.gorgias.com/reference/list-customers
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { gorgiasGet, gorgiasGetter } = require('../gorgias/gorgiasGet');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const gorgiasCustomersGet = async (
+  returnGetter,
+
+  credsPayload,
+  getterOptions = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const getterArgs = [
+    credsPayload,
+    '/customers',
+    getterOptions,
+  ];
+
+  return returnGetter
+    ? gorgiasGetter(...getterArgs)
+    : gorgiasGet(...getterArgs);
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  gorgiasCustomersGet: (...args) => gorgiasCustomersGet(false, ...args),
+  gorgiasCustomersGetter: (...args) => gorgiasCustomersGet(true, ...args),
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/gorgiasCustomersGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "gorgias" },
+    "options": {
+      "params": { "email": "customer@example.com" },
+      "limit": 10
+    }
+  }'
+*/