@foxtware/mineral 0.1.0 → 0.1.2

package/api/logiwa/logiwaAuthGet.js

@@ -0,0 +1,86 @@
+// https://myapi.logiwa.com/swagger/index.html
+
+const { credsFromPayload, customFetch, appendUrlToBase, ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { DEFAULT_API_VERSION } = require('./logiwa.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const logiwaAuthGet = async (
+  credsPayload,
+  {
+    apiVersion = DEFAULT_API_VERSION,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const creds = await credsFromPayload(credsPayload);
+  const {
+    BASE_URL,
+    EMAIL,
+    PASSWORD,
+  } = creds;
+
+  if (!EMAIL || !PASSWORD) {
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_CREDS',
+        message: 'EMAIL and PASSWORD are required.',
+      },
+    };
+  }
+
+  const url = appendUrlToBase(BASE_URL, `/${ apiVersion }/Authorize/token`);
+
+  const response = await customFetch(
+    url,
+    {
+      method: 'post',
+      body: {
+        email: EMAIL,
+        password: PASSWORD,
+      },
+    },
+  );
+
+  if (!response.ok) {
+    return response;
+  }
+
+  if (!response.data?.token) {
+    return {
+      ok: false,
+      error: {
+        code: 'AUTH_FAILED',
+        message: 'Logiwa did not return a token.',
+        details: response.data,
+      },
+    };
+  }
+
+  return response;
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  logiwaAuthGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/logiwaAuthGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" }
+  }'
+*/

package/api/logiwa/logiwaInventoriesGet.js

@@ -0,0 +1,67 @@
+// https://myapi.logiwa.com/swagger/index.html#/Inventory/get_v3_1_Inventory_list_i__index__s__size_
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { logiwaClient } = require('../logiwa/logiwa.utils');
+const { MAX_PER_PAGE } = require('../logiwa/logiwa.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const logiwaInventoriesGet = async (
+  credsPayload,
+  {
+    apiVersion,
+    page = 0,
+    perPage = MAX_PER_PAGE,
+    sku_eq,
+    clientIdentifier_eq,
+    warehouseIdentifier_eq,
+    inventoryStatusId_eq,
+    location_eq,
+    useSnapshotData_eq,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const params = {
+    ...(sku_eq && { 'Sku.eq': sku_eq }),
+    ...(clientIdentifier_eq && { 'ClientIdentifier.eq': clientIdentifier_eq }),
+    ...(warehouseIdentifier_eq && { 'WarehouseIdentifier.eq': warehouseIdentifier_eq }),
+    ...(inventoryStatusId_eq && { 'InventoryStatusId.eq': inventoryStatusId_eq }),
+    ...(location_eq && { 'Location.eq': location_eq }),
+    ...(useSnapshotData_eq && { 'UseSnapshotData.eq': useSnapshotData_eq }),
+  };
+
+  return logiwaClient.fetch({
+    method: 'get',
+    url: `/Inventory/list/i/${ page }/s/${ perPage }`,
+    params,
+    context: {
+      credsPayload,
+      apiVersion,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  logiwaInventoriesGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/logiwaInventoriesGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" }
+  }'
+*/

package/api/logiwa/logiwaOrderGet.js

@@ -0,0 +1,54 @@
+// https://myapi.logiwa.com/swagger/index.html#/ShipmentOrder/get_v3_1_ShipmentOrder__identifier_
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { logiwaClient } = require('../logiwa/logiwa.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['orderId'],
+]);
+
+const logiwaOrderGet = async (
+  credsPayload,
+  orderId, // Logiwa order UUID
+  {
+    apiVersion,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    orderId,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return logiwaClient.fetch({
+    method: 'get',
+    url: `/ShipmentOrder/${ orderId }`,
+    context: {
+      credsPayload,
+      apiVersion,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  logiwaOrderGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/logiwaOrderGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" },
+    "orderId": "d53b375b-835d-4450-b71b-65e333f6709b"
+  }'
+*/

package/api/logiwa/logiwaOrdersGet.js

@@ -0,0 +1,92 @@
+// https://myapi.logiwa.com/swagger/index.html#/ShipmentOrder/get_v3_1_ShipmentOrder_list_i__index__s__size_
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { logiwaClient } = require('../logiwa/logiwa.utils');
+const { MAX_PER_PAGE } = require('../logiwa/logiwa.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const logiwaOrdersGet = async (
+  credsPayload,
+  {
+    apiVersion,
+    page = 0,
+    perPage = MAX_PER_PAGE,
+    sku_eq,
+    updatedDateTime_bt,
+    code_eq,
+    warehouseIdentifier_eq,
+    warehouseIdentifier_in,
+    identifier_eq,
+    clientIdentifier_eq,
+    clientIdentifier_in,
+    createdDateTime_bt,
+    actualShipmentDate_bt,
+    shipmentOrderDate_bt,
+    status_in,
+    status_eq,
+    expectedShipmentDate_bt,
+    shipmentOrderTypeName_eq,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const params = {
+    ...(sku_eq && { 'Sku.eq': sku_eq }),
+    ...(updatedDateTime_bt && { 'UpdatedDateTime.bt': updatedDateTime_bt }),
+    ...(code_eq && { 'Code.eq': code_eq }),
+    ...(warehouseIdentifier_eq && { 'WarehouseIdentifier.eq': warehouseIdentifier_eq }),
+    ...(warehouseIdentifier_in && { 'WarehouseIdentifier.in': warehouseIdentifier_in }),
+    ...(identifier_eq && { 'Identifier.eq': identifier_eq }),
+    ...(clientIdentifier_eq && { 'ClientIdentifier.eq': clientIdentifier_eq }),
+    ...(clientIdentifier_in && { 'ClientIdentifier.in': clientIdentifier_in }),
+    ...(createdDateTime_bt && { 'CreatedDateTime.bt': createdDateTime_bt }),
+    ...(actualShipmentDate_bt && { 'ActualShipmentDate.bt': actualShipmentDate_bt }),
+    ...(shipmentOrderDate_bt && { 'ShipmentOrderDate.bt': shipmentOrderDate_bt }),
+    ...(status_in && { 'Status.in': status_in }),
+    ...(status_eq && { 'Status.eq': status_eq }),
+    ...(expectedShipmentDate_bt && { 'ExpectedShipmentDate.bt': expectedShipmentDate_bt }),
+    ...(shipmentOrderTypeName_eq && { 'ShipmentOrderTypeName.eq': shipmentOrderTypeName_eq }),
+  };
+
+  return logiwaClient.fetch({
+    method: 'get',
+    url: `/ShipmentOrder/list/i/${ page }/s/${ perPage }`,
+    params,
+    context: {
+      credsPayload,
+      apiVersion,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  logiwaOrdersGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/logiwaOrdersGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" }
+  }'
+
+curl -X POST "http://localhost:8000/logiwaOrdersGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" },
+    "options": { "code_eq": "#USA5674542" }
+  }'
+*/

package/api/logiwa/logiwaProductGet.js

@@ -0,0 +1,54 @@
+// https://myapi.logiwa.com/swagger/index.html#/Product/get_v3_1_Product_detail__id_
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { logiwaClient } = require('../logiwa/logiwa.utils');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['productId'],
+]);
+
+const logiwaProductGet = async (
+  credsPayload,
+  productId,
+  {
+    apiVersion,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    productId,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return logiwaClient.fetch({
+    method: 'get',
+    url: `/Product/detail/${ productId }`,
+    context: {
+      credsPayload,
+      apiVersion,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  logiwaProductGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/logiwaProductGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" },
+    "productId": "261a02aa-ce5a-4b06-a528-d419e0aa87a1"
+  }'
+*/

package/api/logiwa/logiwaProductsGet.js

@@ -0,0 +1,80 @@
+// https://myapi.logiwa.com/swagger/index.html#/Product/get_v3_1_Product_list_i__index__s__size_
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { logiwaClient } = require('../logiwa/logiwa.utils');
+const { MAX_PER_PAGE } = require('../logiwa/logiwa.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+]);
+
+const logiwaProductsGet = async (
+  credsPayload,
+  {
+    apiVersion,
+    page = 0,
+    perPage = MAX_PER_PAGE,
+    sku_eq,
+    fnsku_eq,
+    clientIdentifier_eq,
+    clientIdentifier_in,
+    identifier_eq,
+    createdDateTime_bt,
+    updatedDateTime_bt,
+    productTypeName_eq,
+    productGroupName_eq,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({ credsPayload });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const params = {
+    ...(sku_eq && { 'Sku.eq': sku_eq }),
+    ...(fnsku_eq && { 'FNSKU.eq': fnsku_eq }),
+    ...(clientIdentifier_eq && { 'ClientIdentifier.eq': clientIdentifier_eq }),
+    ...(clientIdentifier_in && { 'ClientIdentifier.in': clientIdentifier_in }),
+    ...(identifier_eq && { 'Identifier.eq': identifier_eq }),
+    ...(createdDateTime_bt && { 'CreatedDateTime.bt': createdDateTime_bt }),
+    ...(updatedDateTime_bt && { 'UpdatedDateTime.bt': updatedDateTime_bt }),
+    ...(productTypeName_eq && { 'ProductTypeName.eq': productTypeName_eq }),
+    ...(productGroupName_eq && { 'ProductGroupName.eq': productGroupName_eq }),
+  };
+
+  return logiwaClient.fetch({
+    method: 'get',
+    url: `/Product/list/i/${ page }/s/${ perPage }`,
+    params,
+    context: {
+      credsPayload,
+      apiVersion,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  logiwaProductsGet,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/logiwaProductsGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" }
+  }'
+
+curl -X POST "http://localhost:8000/logiwaProductsGet" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" },
+    "options": { "sku_eq": "EXD1684-2-L" }
+  }'
+*/

package/api/logiwa/logiwaReportGetAvailableToPromise.js

@@ -0,0 +1,179 @@
+// https://myapi.logiwa.com/swagger/index.html#/Report/get_v3_1_Report_AvailableToPromise_i__index__s__size_
+
+const { ArgsWarden, actionSingleOrMultiple } = require('../utils');
+const { credsValidator } = require('../validators');
+const { logiwaClient } = require('../logiwa/logiwa.utils');
+const { DEFAULT_API_VERSION, MAX_PER_PAGE } = require('../logiwa/logiwa.constants');
+
+const isSet = (value) => {
+  if (value === 0 || value === false || value === '') {
+    return true;
+  }
+
+  return Boolean(value);
+};
+
+const logiwaReportGetAvailableToPromiseSingle = async (
+  credsPayload,
+  {
+    apiVersion = DEFAULT_API_VERSION,
+    page = 0,
+    perPage = MAX_PER_PAGE,
+    sku_eq,
+    clientIdentifier_eq,
+    clientIdentifier_in,
+    warehouseIdentifier_eq,
+    warehouseIdentifier_in,
+    plannedAtpQuantity_eq,
+    plannedAtpQuantity_gt,
+    plannedAtpQuantity_lt,
+    plannedAtpQuantity_gte,
+    plannedAtpQuantity_lte,
+    totalStockQuantity_eq,
+    totalStockQuantity_gt,
+    totalStockQuantity_lt,
+    totalStockQuantity_gte,
+    totalStockQuantity_lte,
+    inventoryAtpQuantity_eq,
+    inventoryAtpQuantity_gt,
+    inventoryAtpQuantity_lt,
+    inventoryAtpQuantity_gte,
+    inventoryAtpQuantity_lte,
+    undamagedQuantity_eq,
+    undamagedQuantity_gt,
+    undamagedQuantity_lt,
+    undamagedQuantity_gte,
+    undamagedQuantity_lte,
+    currentAtpQuantity_eq,
+    currentAtpQuantity_gt,
+    currentAtpQuantity_lt,
+    currentAtpQuantity_gte,
+    currentAtpQuantity_lte,
+  } = {},
+) => {
+
+  const params = {
+    ...(sku_eq && { 'Sku.eq': sku_eq }),
+    ...(clientIdentifier_eq && { 'ClientIdentifier.eq': clientIdentifier_eq }),
+    ...(clientIdentifier_in && { 'ClientIdentifier.in': clientIdentifier_in }),
+    ...(warehouseIdentifier_eq && { 'WarehouseIdentifier.eq': warehouseIdentifier_eq }),
+    ...(warehouseIdentifier_in && { 'WarehouseIdentifier.in': warehouseIdentifier_in }),
+    ...(isSet(plannedAtpQuantity_eq) && { 'PlannedATPQuantity.eq': plannedAtpQuantity_eq }),
+    ...(isSet(plannedAtpQuantity_gt) && { 'PlannedATPQuantity.gt': plannedAtpQuantity_gt }),
+    ...(isSet(plannedAtpQuantity_lt) && { 'PlannedATPQuantity.lt': plannedAtpQuantity_lt }),
+    ...(isSet(plannedAtpQuantity_gte) && { 'PlannedATPQuantity.gte': plannedAtpQuantity_gte }),
+    ...(isSet(plannedAtpQuantity_lte) && { 'PlannedATPQuantity.lte': plannedAtpQuantity_lte }),
+    ...(apiVersion === 'v3.1' ? {
+      ...(isSet(totalStockQuantity_eq) && { 'TotalStockQuantity.eq': totalStockQuantity_eq }),
+      ...(isSet(totalStockQuantity_gt) && { 'TotalStockQuantity.gt': totalStockQuantity_gt }),
+      ...(isSet(totalStockQuantity_lt) && { 'TotalStockQuantity.lt': totalStockQuantity_lt }),
+      ...(isSet(totalStockQuantity_gte) && { 'TotalStockQuantity.gte': totalStockQuantity_gte }),
+      ...(isSet(totalStockQuantity_lte) && { 'TotalStockQuantity.lte': totalStockQuantity_lte }),
+      ...(isSet(inventoryAtpQuantity_eq) && { 'InventoryATPQuantity.eq': inventoryAtpQuantity_eq }),
+      ...(isSet(inventoryAtpQuantity_gt) && { 'InventoryATPQuantity.gt': inventoryAtpQuantity_gt }),
+      ...(isSet(inventoryAtpQuantity_lt) && { 'InventoryATPQuantity.lt': inventoryAtpQuantity_lt }),
+      ...(isSet(inventoryAtpQuantity_gte) && { 'InventoryATPQuantity.gte': inventoryAtpQuantity_gte }),
+      ...(isSet(inventoryAtpQuantity_lte) && { 'InventoryATPQuantity.lte': inventoryAtpQuantity_lte }),
+    } : {}),
+    ...(apiVersion === 'v3.2' ? {
+      ...(isSet(undamagedQuantity_eq) && { 'UndamagedQuantity.eq': undamagedQuantity_eq }),
+      ...(isSet(undamagedQuantity_gt) && { 'UndamagedQuantity.gt': undamagedQuantity_gt }),
+      ...(isSet(undamagedQuantity_lt) && { 'UndamagedQuantity.lt': undamagedQuantity_lt }),
+      ...(isSet(undamagedQuantity_gte) && { 'UndamagedQuantity.gte': undamagedQuantity_gte }),
+      ...(isSet(undamagedQuantity_lte) && { 'UndamagedQuantity.lte': undamagedQuantity_lte }),
+      ...(isSet(currentAtpQuantity_eq) && { 'CurrentATPQuantity.eq': currentAtpQuantity_eq }),
+      ...(isSet(currentAtpQuantity_gt) && { 'CurrentATPQuantity.gt': currentAtpQuantity_gt }),
+      ...(isSet(currentAtpQuantity_lt) && { 'CurrentATPQuantity.lt': currentAtpQuantity_lt }),
+      ...(isSet(currentAtpQuantity_gte) && { 'CurrentATPQuantity.gte': currentAtpQuantity_gte }),
+      ...(isSet(currentAtpQuantity_lte) && { 'CurrentATPQuantity.lte': currentAtpQuantity_lte }),
+    } : {}),
+  };
+
+  if (!Object.keys(params).length) {
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_CRITERIA',
+        message: 'At least one filter is required, and criteria must match the API version.',
+      },
+    };
+  }
+
+  return logiwaClient.fetch({
+    method: 'get',
+    url: `/Report/AvailableToPromise/i/${ page }/s/${ perPage }`,
+    params,
+    context: {
+      credsPayload,
+      apiVersion,
+    },
+  });
+};
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['criteria'],
+]);
+
+const logiwaReportGetAvailableToPromise = async (
+  credsPayload,
+  criteria,
+  {
+    queueRunOptions,
+    ...options
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    criteria,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  return actionSingleOrMultiple(
+    criteria,
+    logiwaReportGetAvailableToPromiseSingle,
+    (singleCriteria) => ({
+      args: [
+        credsPayload,
+        {
+          ...singleCriteria,
+          ...options,
+        },
+      ],
+    }),
+    {
+      ...(queueRunOptions ? { queueRunOptions } : {}),
+    },
+  );
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  logiwaReportGetAvailableToPromise,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/logiwaReportGetAvailableToPromise" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" },
+    "criteria": { "clientIdentifier_eq": "9f1ea39a-fccc-48af-8986-a35c34fcef8b" }
+  }'
+
+curl -X POST "http://localhost:8000/logiwaReportGetAvailableToPromise" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" },
+    "criteria": [
+      { "sku_eq": "EXDAL355-15-S/M" },
+      { "sku_eq": "EXD535-1-XXS/XS" }
+    ]
+  }'
+*/

package/api/logiwa/logiwaReportGetInventoryCalculation.js

@@ -0,0 +1,62 @@
+// https://myapi.logiwa.com/swagger/index.html#/Report/get_v3_1_Report_InventoryCalculation_i__index__s__size_
+
+const { ArgsWarden } = require('../utils');
+const { credsValidator } = require('../validators');
+const { logiwaClient } = require('../logiwa/logiwa.utils');
+const { MAX_PER_PAGE } = require('../logiwa/logiwa.constants');
+
+const argsWarden = new ArgsWarden([
+  ['credsPayload', credsValidator],
+  ['warehouseIdentifier_eq'],
+]);
+
+const logiwaReportGetInventoryCalculation = async (
+  credsPayload,
+  warehouseIdentifier_eq,
+  {
+    apiVersion,
+    page = 0,
+    perPage = MAX_PER_PAGE,
+  } = {},
+) => {
+
+  const rejectResponse = await argsWarden.responseIfRejectingArgs({
+    credsPayload,
+    warehouseIdentifier_eq,
+  });
+  if (rejectResponse) {
+    return rejectResponse;
+  }
+
+  const params = {
+    'WarehouseIdentifier.eq': warehouseIdentifier_eq,
+  };
+
+  return logiwaClient.fetch({
+    method: 'get',
+    url: `/Report/InventoryCalculation/i/${ page }/s/${ perPage }`,
+    params,
+    context: {
+      credsPayload,
+      apiVersion,
+    },
+  });
+};
+
+const funcApiConfig = {
+  argsWarden,
+};
+
+module.exports = {
+  logiwaReportGetInventoryCalculation,
+  funcApiConfig,
+};
+
+/*
+curl -X POST "http://localhost:8000/logiwaReportGetInventoryCalculation" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "credsPayload": { "credsPath": "logiwa" },
+    "warehouseIdentifier_eq": "cfbdf154-3052-4e18-84f3-b93b7cde2875"
+  }'
+*/