integreat 0.7.33 → 0.7.37

package/lib/actions/sync.js

@@ -4,66 +4,124 @@ const pLimit = require('p-limit')
 const action = require('../utils/createAction')
 const createError = require('../utils/createError')
 
-const createTransformAction = ({ action: type, ...payload }, data, { ident, project }) =>
-  action(type, { ...payload, data }, { ident, project })
-
-const makeErrorString = (results) => results
-  .map((result, index) => (result.status === 'ok') ? null : `[${index}]: ${result.error}`)
-  .filter(Boolean)
-  .join('\n')
+const createTransformAction = (
+  { action: type, ...payload },
+  data,
+  { ident, project }
+) => action(type, { ...payload, data }, { ident, project })
+
+const makeErrorString = (results) =>
+  results
+    .map((result, index) =>
+      result.status === 'ok' ? null : `[${index}]: ${result.error}`
+    )
+    .filter(Boolean)
+    .join('\n')
 
 const addDeltaToDate = (date, delta) =>
   delta ? new Date(date.getTime() + delta) : date
 
 const generateUpdatedAfter = (updatedAfter, afterDelta) => ({
   updatedAfter: addDeltaToDate(updatedAfter, afterDelta),
-  updatedSince: addDeltaToDate(updatedAfter, 1)
+  updatedSince: addDeltaToDate(updatedAfter, 1),
 })
 
-const setUpdatedParams = (dispatch, dontSetUntil, afterDelta, untilDelta, metaKey, ident) => async (params) => {
-  const { status, data, error } = await dispatch(
-    action('GET_META', { service: params.service, metaKey, keys: 'lastSyncedAt' }, { ident })
-  )
+const setUpdatedParams =
+  (dispatch, dontSetUntil, afterDelta, untilDelta, metaKey, ident) =>
+  async (params) => {
+    const { status, data, error } = await dispatch(
+      action(
+        'GET_META',
+        { service: params.service, metaKey, keys: 'lastSyncedAt' },
+        { ident }
+      )
+    )
 
-  if (status === 'ok' && data && data.meta && data.meta.lastSyncedAt) {
-    return {
-      ...params,
-      ...generateUpdatedAfter(data.meta.lastSyncedAt, afterDelta),
-      updatedUntil: dontSetUntil ? undefined : addDeltaToDate(new Date(), untilDelta)
+    if (status === 'ok' && data && data.meta && data.meta.lastSyncedAt) {
+      return {
+        ...params,
+        ...generateUpdatedAfter(data.meta.lastSyncedAt, afterDelta),
+        updatedUntil: dontSetUntil
+          ? undefined
+          : addDeltaToDate(new Date(), untilDelta),
+      }
+    } else {
+      debug(
+        'SYNC: Could not get meta for service %s. Error: %s %s',
+        params.service,
+        status,
+        error
+      )
     }
-  } else {
-    debug('SYNC: Could not get meta for service %s. Error: %s %s', params.service, status, error)
+    return params
   }
-  return params
-}
 
-const generateParamsWithUpdatedDates = async (params, dispatch, ident, updatedAfter, updatedUntil, afterDelta, untilDelta, metaKey) => {
+const generateParamsWithUpdatedDates = async (
+  params,
+  dispatch,
+  ident,
+  updatedAfter,
+  updatedUntil,
+  afterDelta,
+  untilDelta,
+  metaKey
+) => {
   if (updatedAfter) {
     return params.map((params) => ({
       ...params,
       ...generateUpdatedAfter(new Date(updatedAfter), afterDelta),
-      updatedUntil: updatedUntil === 'open'
-        ? undefined
-        : addDeltaToDate(updatedUntil ? new Date(updatedUntil) : new Date(), untilDelta)
+      updatedUntil:
+        updatedUntil === 'open'
+          ? undefined
+          : addDeltaToDate(
+              updatedUntil ? new Date(updatedUntil) : new Date(),
+              untilDelta
+            ),
     }))
   } else {
     return Promise.all(
-      params.map(setUpdatedParams(dispatch, updatedUntil === 'open', afterDelta, untilDelta, metaKey, ident))
+      params.map(
+        setUpdatedParams(
+          dispatch,
+          updatedUntil === 'open',
+          afterDelta,
+          untilDelta,
+          metaKey,
+          ident
+        )
+      )
     )
   }
 }
 
 const paramsFromStringOrObject = (params) =>
-  (typeof params === 'string') ? { service: params } : params
+  typeof params === 'string' ? { service: params } : params
 
 const generateFromParams = async (
-  { retrieve, from, updatedAfter, updatedUntil, afterDelta, untilDelta, metaKey },
+  {
+    retrieve,
+    from,
+    updatedAfter,
+    updatedUntil,
+    afterDelta,
+    untilDelta,
+    metaKey,
+  },
   { ident },
   dispatch
 ) => {
   const fromParams = [].concat(from).map(paramsFromStringOrObject)
   if (retrieve === 'updated') {
-    return generateParamsWithUpdatedDates(fromParams, dispatch, ident, updatedAfter, updatedUntil, afterDelta, untilDelta, metaKey)
+    return generateParamsWithUpdatedDates(
+      fromParams,
+      dispatch,
+      ident,
+      updatedAfter,
+      updatedUntil,
+      afterDelta,
+      untilDelta,
+      metaKey
+    )
   } else {
     return fromParams
   }
@@ -89,15 +147,15 @@ const generateTransformParams = ({ transform }, { service, type }) => {
 const generateToParams = ({ to, type }, fromParams) => {
   const { updatedAfter, updatedUntil } = fromParams[0]
   return {
-    ...((typeof to === 'string') ? { service: to } : to),
+    ...(typeof to === 'string' ? { service: to } : to),
     type,
     updatedAfter,
-    updatedUntil
+    updatedUntil,
   }
 }
 
 const filterDataOnUpdatedDates = (data, updatedAfter, updatedUntil) =>
-  (Array.isArray(data) && data.length > 0 && (updatedAfter || updatedUntil))
+  Array.isArray(data) && data.length > 0 && (updatedAfter || updatedUntil)
     ? data.filter(isWithinUpdateWindow(updatedAfter, updatedUntil))
     : data
 
@@ -106,66 +164,124 @@ const isWithinUpdateWindow = (updatedAfter, updatedUntil) => (item) =>
   (!updatedAfter || item.attributes.updatedAt > updatedAfter) &&
   (!updatedUntil || item.attributes.updatedAt <= updatedUntil)
 
-const getFromService = (dispatch, type, noFilter = false, { project, ident }) =>
+const getFromService =
+  (dispatch, type, noFilter = false, { project, ident }) =>
   async ({ action: fromAction = 'GET', ...fromParams }) => {
-    const response = await dispatch(action(fromAction, { type, ...fromParams }, { project, ident }))
+    const response = await dispatch(
+      action(fromAction, { type, ...fromParams }, { project, ident })
+    )
     if (response.status !== 'ok') {
-      return createError(`Could not get items from service '${fromParams.service}'. Reason: ${response.status} ${response.error}`)
+      return createError(
+        `Could not get items from service '${fromParams.service}'. Reason: ${response.status} ${response.error}`
+      )
     }
 
     return {
       status: 'ok',
-      data: noFilter ? response.data : filterDataOnUpdatedDates(response.data, fromParams.updatedAfter, fromParams.updatedUntil)
+      data: noFilter
+        ? response.data
+        : filterDataOnUpdatedDates(
+            response.data,
+            fromParams.updatedAfter,
+            fromParams.updatedUntil
+          ),
     }
   }
 
-function isConfiguredWithMeta (serviceId, getService) {
+function isConfiguredWithMeta(serviceId, getService) {
   const service = getService(null, serviceId)
   return !!(service && service.meta)
 }
 
-const createSetMetas = (fromParams, lastSyncedAt, metaKey, ident, dispatch, getService) => fromParams
-  .reduce((services, params) =>
-    (
-      params.service &&
-      !services.includes(params.service) &&
-      isConfiguredWithMeta(params.service, getService)
+const createSetMetas = (
+  fromParams,
+  lastSyncedAt,
+  metaKey,
+  ident,
+  dispatch,
+  getService
+) =>
+  fromParams
+    .reduce(
+      (services, params) =>
+        params.service &&
+        !services.includes(params.service) &&
+        isConfiguredWithMeta(params.service, getService)
+          ? [...services, params.service]
+          : services,
+      []
+    )
+    .map((service) =>
+      dispatch(
+        action(
+          'SET_META',
+          { service, metaKey, meta: { lastSyncedAt } },
+          { ident }
+        )
+      )
     )
-      ? [...services, params.service] : services,
-  [])
-  .map((service) =>
-    dispatch(action('SET_META', { service, metaKey, meta: { lastSyncedAt } }, { ident })))
 
 const createSetActions = (toAction, data, toParams, meta, useIndividualSet) =>
   useIndividualSet
-    ? data.map(item => action(toAction, { data: item, ...toParams }, meta))
+    ? data.map((item) => action(toAction, { data: item, ...toParams }, meta))
     : [action(toAction, { data, ...toParams }, meta)]
 
-const createDoneAction = (data, { action: type = 'SET', ...params }, { ident, project }) => ({
+const createDoneAction = (
+  data,
+  { action: type = 'SET', ...params },
+  { ident, project }
+) => ({
   type,
   payload: { ...params, data },
-  meta: { ident, project }
+  meta: { ident, project },
 })
 
 const isError = (response) =>
   !['ok', 'queued', 'noaction'].includes(response.status)
 
-const getLastSyncedAt = (fromParams, data, setLastSyncedAtFromData = false) =>
-  setLastSyncedAtFromData
-    ? data.map(item => item.attributes.updatedAt).reduce((latest, date) => latest > date ? latest : date)
-    : (fromParams[0] && fromParams[0].updatedUntil) // TODO: Pick the latest date, not just the first
-
-async function transformData (data, dispatch, transformParams, meta, useIndividualTransform) {
+function getLastSyncedAt(
+  fromParams,
+  data,
+  setLastSyncedAtFromData = false,
+  untilDelta = 0
+) {
+  if (setLastSyncedAtFromData) {
+    return data
+      .map((item) => item.attributes.updatedAt)
+      .reduce((latest, date) => (latest > date ? latest : date))
+  } else if (fromParams[0]) {
+    const lastSyncedAt = fromParams
+      .map((param) => param.updatedUntil)
+      .sort((a, b) =>
+        a instanceof Date && b instanceof Date ? a.getTime() - b.getTime() : 0
+      )[0]
+    return addDeltaToDate(lastSyncedAt, untilDelta * -1) // Subtract delta to get the actual updatedUntil date
+  }
+  return undefined
+}
+async function transformData(
+  data,
+  dispatch,
+  transformParams,
+  meta,
+  useIndividualTransform
+) {
   if (useIndividualTransform) {
     const responses = await Promise.all(
       data
-        .map(item => dispatch(createTransformAction(transformParams, item, meta)))
-        .map(p => pLimit(1)(() => p))
+        .map((item) =>
+          dispatch(createTransformAction(transformParams, item, meta))
+        )
+        .map((p) => pLimit(1)(() => p))
+    )
+    return responses.flatMap((response, index) =>
+      response.status === 'ok' ? response.data : data[index]
     )
-    return responses.flatMap((response, index) => response.status === 'ok' ? response.data : data[index])
   } else {
-    const transformResponse = await dispatch(createTransformAction(transformParams, data, meta))
-    return (transformResponse.status === 'ok') ? transformResponse.data : data
+    const transformResponse = await dispatch(
+      createTransformAction(transformParams, data, meta)
+    )
+    return transformResponse.status === 'ok' ? transformResponse.data : data
   }
 }
 
@@ -186,36 +302,61 @@ async function transformData (data, dispatch, transformParams, meta, useIndividu
  * @param {Object} resources - Dispatch function
  * @returns {Promise} Promise of the action result
  */
-async function sync ({ payload, meta = {} }, { dispatch, getService }) {
+async function sync({ payload, meta = {} }, { dispatch, getService }) {
   debug('Action: SYNC')
   const fromParams = await generateFromParams(payload, meta, dispatch)
-  const { action: toAction = 'SET', ...toParams } = generateToParams(payload, fromParams)
+  const { action: toAction = 'SET', ...toParams } = generateToParams(
+    payload,
+    fromParams
+  )
   const transformParams = generateTransformParams(payload, toParams)
   const { queueSet = true, metaKey, useIndividualSet = false } = payload
   const doneParams = generateDoneParams(payload)
 
   const results = await Promise.all(
-    fromParams.map(getFromService(dispatch, payload.type, payload.noFilter, meta))
+    fromParams.map(
+      getFromService(dispatch, payload.type, payload.noFilter, meta)
+    )
   )
 
   if (results.some((result) => result.status !== 'ok')) {
-    return (results.length === 1) ? results[0] : createError(makeErrorString(results))
+    return results.length === 1
+      ? results[0]
+      : createError(makeErrorString(results))
   }
 
   let data = flatten(results.map((result) => result.data)).filter(Boolean)
 
   if (data.length === 0 && payload.syncNoData !== true) {
-    return createError(`No items to update from service '${fromParams[0].service}'`, 'noaction')
+    return createError(
+      `No items to update from service '${fromParams[0].service}'`,
+      'noaction'
+    )
   }
 
-  const lastSyncedAt = getLastSyncedAt(fromParams, data, payload.setLastSyncedAtFromData) || new Date()
+  const lastSyncedAt =
+    getLastSyncedAt(
+      fromParams,
+      data,
+      payload.setLastSyncedAtFromData,
+      payload.untilDelta
+    ) || new Date()
 
   // Dispatch transform action
   if (transformParams) {
-    data = await transformData(data, dispatch, transformParams, meta, payload.useIndividualTransform)
+    data = await transformData(
+      data,
+      dispatch,
+      transformParams,
+      meta,
+      payload.useIndividualTransform
+    )
 
     if (data.length === 0 && payload.syncNoData !== true) {
-      return createError(`No items to update from service '${fromParams[0].service}' after transform action`, 'noaction')
+      return createError(
+        `No items to update from service '${fromParams[0].service}' after transform action`,
+        'noaction'
+      )
     }
   }
 
@@ -236,10 +377,11 @@ async function sync ({ payload, meta = {} }, { dispatch, getService }) {
   )
 
   // Dispatch set actions
-  const responses = await Promise.all([
-    ...setMetaActions,
-    ...setActions.map(dispatch)
-  ].map(p => pLimit(1)(() => p)))
+  const responses = await Promise.all(
+    [...setMetaActions, ...setActions.map(dispatch)].map((p) =>
+      pLimit(1)(() => p)
+    )
+  )
 
   // Get responses, excluding set meta actions
   const setResponses = responses.slice(setMetaActions.length)
@@ -258,7 +400,9 @@ async function sync ({ payload, meta = {} }, { dispatch, getService }) {
   return {
     status: errors.length ? 'error' : 'ok',
     data: setResponses,
-    ...(errors.length ? { error: `${errors.length} of ${setResponses.length} actions failed` } : {})
+    ...(errors.length
+      ? { error: `${errors.length} of ${setResponses.length} actions failed` }
+      : {}),
   }
 }
 

package/lib/authenticators/options.js

@@ -12,7 +12,7 @@ const optionsAuth = {
    * @param {Object} options - An options object
    * @returns {Object} An authentication object
    */
-  async authenticate (options) {
+  async authenticate(options) {
     return { status: 'granted', ...options }
   },
 
@@ -23,7 +23,7 @@ const optionsAuth = {
    * @param {Object} authentication - The object returned from `authenticate()`
    * @returns {boolean} `true` if already authenticated, otherwise `false`
    */
-  isAuthenticated (authentication) {
+  isAuthenticated(authentication) {
     return !!(authentication && authentication.status === 'granted')
   },
 
@@ -35,8 +35,8 @@ const optionsAuth = {
    * @param {Object} authentication - The object returned from `authenticate()`
    * @returns {Object} Auth object
    */
-  asObject ({ status, ...options }) {
-    return (status === 'granted') ? options : {}
+  asObject({ status, ...options }) {
+    return status === 'granted' ? options : {}
   },
 
   /**
@@ -45,9 +45,9 @@ const optionsAuth = {
    * @param {Object} authentication - The object returned from `authenticate()`
    * @returns {Object} Headers object
    */
-  asHttpHeaders (authentication) {
-    return {}
-  }
+  asHttpHeaders({ status, ...options }) {
+    return status === 'granted' ? options : {}
+  },
 }
 
 module.exports = optionsAuth

package/lib/dispatch.js

@@ -1,7 +1,13 @@
 const debug = require('debug')('great')
+const PProgress = require('p-progress')
 const setupGetService = require('./utils/getService')
 
-const compose = (...fns) => fns.reduce((f, g) => (...args) => f(g(...args)))
+const compose = (...fns) =>
+  fns.reduce(
+    (f, g) =>
+      (...args) =>
+        f(g(...args))
+  )
 
 const handleAction = (action, resources, actionHandlers) => {
   if (action) {
@@ -13,7 +19,7 @@ const handleAction = (action, resources, actionHandlers) => {
     }
   }
 
-  return { status: 'noaction' }
+  return PProgress.resolve({ status: 'noaction' })
 }
 
 /**
@@ -22,26 +28,44 @@ const handleAction = (action, resources, actionHandlers) => {
  * @param {Object} resources - Object with actions, schemas, services, and middlewares
  * @returns {function} Dispatch function, accepting an action as only argument
  */
-function setupDispatch ({ actions: actionHandlers = {}, schemas = {}, services = {}, middlewares = [], identOptions = {} }) {
+function setupDispatch({
+  actions: actionHandlers = {},
+  schemas = {},
+  services = {},
+  middlewares = [],
+  identOptions = {},
+}) {
   const getService = setupGetService(schemas, services)
+  const middlewareFn =
+    middlewares.length > 0
+      ? compose(...middlewares)
+      : (next) => async (action) => next(action)
 
-  let dispatch = async (action) => {
-    debug('Dispatch: %o', action)
-    return handleAction(
-      action,
-      {
-        schemas,
-        services,
-        dispatch,
-        identOptions,
-        getService
-      },
-      actionHandlers
-    )
-  }
+  const dispatch = (action) => {
+    return new PProgress(async (resolve, reject, setProgress) => {
+      debug('Dispatch: %o', action)
 
-  if (middlewares.length > 0) {
-    dispatch = compose(...middlewares)(dispatch)
+      try {
+        resolve(
+          middlewareFn((action) =>
+            handleAction(
+              action,
+              {
+                schemas,
+                services,
+                dispatch,
+                identOptions,
+                getService,
+                setProgress,
+              },
+              actionHandlers
+            )
+          )(action)
+        )
+      } catch (err) {
+        reject(err)
+      }
+    })
   }
 
   return dispatch

package/lib/integreat.js

@@ -5,7 +5,7 @@ const setupMapping = require('./mapping')
 const setupDispatch = require('./dispatch')
 const builtinActions = require('./actions')
 
-const version = '0.7.33'
+const version = '0.7.37'
 
 /**
  * Return an Integreat instance with a dispatch method.
@@ -16,20 +16,20 @@ const version = '0.7.33'
  * @param {Array} middlewares - Array of middlewares
  * @returns {Object} Integration object with the dispatch method
  */
-function integreat (
+function integreat(
   {
     schemas: typeDefs,
     services: serviceDefs,
     mappings = [],
     auths: authDefs = [],
-    ident: identOptions = {}
+    ident: identOptions = {},
   },
   {
     adapters = {},
     authenticators = {},
     filters = {},
     transformers = {},
-    actions = {}
+    actions = {},
   } = {},
   middlewares = []
 ) {
@@ -41,38 +41,46 @@ function integreat (
   actions = { ...builtinActions, ...actions }
 
   // Setup schemas object from type defs
-  const schemas = R.compose(
-    R.indexBy(R.prop('id')),
-    R.map(schema)
-  )(typeDefs)
+  const schemas = R.compose(R.indexBy(R.prop('id')), R.map(schema))(typeDefs)
 
-  const pluralTypes = Object.keys(schemas)
-    .reduce((plurals, type) => ({ ...plurals, [schemas[type].plural]: type }), {})
+  const pluralTypes = Object.keys(schemas).reduce(
+    (plurals, type) => ({ ...plurals, [schemas[type].plural]: type }),
+    {}
+  )
 
   // Setup auths object from auth defs
-  const auths = authDefs
-    .reduce((auths, def) => (def)
-      ? {
-        ...auths,
-        [def.id]: {
-          authenticator: authenticators[def && def.authenticator],
-          options: def.options,
-          authentication: null
-        }
-      }
-      : auths,
-    {})
+  const auths = authDefs.reduce(
+    (auths, def) =>
+      def
+        ? {
+            ...auths,
+            [def.id]: {
+              authenticator: authenticators[def && def.authenticator],
+              options: def.options,
+              authentication: null,
+            },
+          }
+        : auths,
+    {}
+  )
 
   // Setup services object from service defs.
   const services = R.compose(
     R.indexBy(R.prop('id')),
-    R.map(createService({
-      adapters,
-      auths,
-      transformers,
-      schemas,
-      setupMapping: setupMapping({ filters, transformers, schemas, mappings })
-    }))
+    R.map(
+      createService({
+        adapters,
+        auths,
+        transformers,
+        schemas,
+        setupMapping: setupMapping({
+          filters,
+          transformers,
+          schemas,
+          mappings,
+        }),
+      })
+    )
   )(serviceDefs)
 
   // Return Integreat instance
@@ -93,14 +101,14 @@ function integreat (
       services,
       schemas,
       middlewares,
-      identOptions
+      identOptions,
     }),
 
     /**
      * Adds the `listener` function to the service's emitter for events with the
      * given `eventName` name.
      */
-    on (eventName, serviceId, listener) {
+    on(eventName, serviceId, listener) {
       const service = services[serviceId]
       if (service && service.on) {
         service.on(eventName, listener)
@@ -110,9 +118,9 @@ function integreat (
     /**
      * Return schema type from its plural form.
      */
-    typeFromPlural (plural) {
+    typeFromPlural(plural) {
       return pluralTypes[plural]
-    }
+    },
   }
 }
 

package/lib/mapping/index.js

@@ -1,33 +1,60 @@
 const { compose, map, mergeDeepWith } = require('ramda')
-const { mapTransform, transform, filter, set, fwd, rev, functions } = require('map-transform')
+const {
+  mapTransform,
+  transform,
+  filter,
+  set,
+  fwd,
+  rev,
+  functions,
+} = require('map-transform')
 const is = require('@sindresorhus/is')
-const { preparePipeline, prepareRevPipeline } = require('../utils/preparePipeline')
-const { normalizeFieldMapping } = require('./normalize')
+const {
+  preparePipeline,
+  prepareRevPipeline,
+} = require('../utils/preparePipeline')
+const { normalizeFieldMapping, pathToPipeline } = require('./normalize')
 
 const { compare } = functions
 
 const hasFieldMappings = (id, attributes, relationships) =>
-  id || Object.keys(attributes).length > 0 || Object.keys(relationships).length > 0
+  id ||
+  Object.keys(attributes).length > 0 ||
+  Object.keys(relationships).length > 0
 
 const prepareRelationship = (normalize, createPipeline) => (relationship) =>
-  (relationship.mapping) ? createPipeline(relationship.mapping, undefined, relationship.path).pipeline : normalize(relationship)
+  relationship.mapping
+    ? createPipeline(relationship.mapping, undefined, relationship.path)
+        .pipeline
+    : normalize(relationship)
 
-function prepareMapping ({ attributes: { id = null, type = null, ...attributes } = {}, relationships = {}, toService = {} }, transformers, createPipeline) {
+function prepareMapping(
+  {
+    attributes: { id = null, type = null, ...attributes } = {},
+    relationships = {},
+    toService = {},
+  },
+  transformers,
+  createPipeline
+) {
   if (hasFieldMappings(id, attributes, relationships)) {
     const normalize = normalizeFieldMapping(transformers)
     return {
-      id: (id) ? normalize(id) : null,
-      type: (type) ? rev(type) : null,
+      id: id ? normalize(id) : null,
+      type: type ? rev(type) : null,
       attributes: map(normalize, attributes),
-      relationships: map(prepareRelationship(normalize, createPipeline), relationships),
-      ...map(normalize, toService)
+      relationships: map(
+        prepareRelationship(normalize, createPipeline),
+        relationships
+      ),
+      ...map(normalize, toService),
     }
   } else {
     return {
       id: 'id',
       type: rev('type'),
       attributes: 'attributes',
-      relationships: 'relationships'
+      relationships: 'relationships',
     }
   }
 }
@@ -39,29 +66,38 @@ const createCompareFilter = ([path, value]) => {
     return []
   }
 }
-const prepareQualifier = (qualifier) => (qualifier) ? createCompareFilter(qualifier.split('=')) : []
+const prepareQualifier = (qualifier) =>
+  qualifier ? createCompareFilter(qualifier.split('=')) : []
 
-const prepareTypeQualifier = ({ attributes = {}, relationships = {}, type }) => (is.emptyObject(attributes) && is.emptyObject(relationships))
-  ? [filter(compare({ path: 'type', match: type }))]
-  : []
+const prepareTypeQualifier = ({ attributes = {}, relationships = {}, type }) =>
+  is.emptyObject(attributes) && is.emptyObject(relationships)
+    ? [filter(compare({ path: 'type', match: type }))]
+    : []
 
-const concatOrRight = (left, right) => (Array.isArray(left)) ? left.concat(right) : right
+const concatOrRight = (left, right) =>
+  Array.isArray(left) ? left.concat(right) : right
 
-const ensureArray = (data) => (Array.isArray(data)) ? data : ((data) ? [data] : [])
+const ensureArray = (data) => (Array.isArray(data) ? data : data ? [data] : [])
 
-const overrideMappingProps = (mapping, overrideType, prependPath) => (mapping)
-  ? {
-    ...mapping,
-    type: overrideType || mapping.type,
-    path: [prependPath, mapping.path].filter(Boolean).join('.')
-  }
-  : undefined
+const joinPaths = (...paths) => paths.filter(Boolean).join('.')
+
+const overrideMappingProps = (mapping, overrideType, prependPath) =>
+  mapping
+    ? {
+        ...mapping,
+        type: overrideType || mapping.type,
+        path: Array.isArray(prependPath)
+          ? prependPath.map((path) => joinPaths(path, mapping.path))
+          : joinPaths(prependPath, mapping.path),
+      }
+    : undefined
 
-const lookupMapping = (mapping, mappings) => (mappings[mapping]) ? { ...mappings[mapping], id: mapping } : null
+const lookupMapping = (mapping, mappings) =>
+  mappings[mapping] ? { ...mappings[mapping], id: mapping } : null
 
 const expandMapping = (mapping, mappings, overrideType, prependPath) =>
   overrideMappingProps(
-    (typeof mapping === 'string') ? lookupMapping(mapping, mappings) : mapping,
+    typeof mapping === 'string' ? lookupMapping(mapping, mappings) : mapping,
     overrideType,
     prependPath
   )
@@ -87,7 +123,7 @@ const createPipelines = (mapping, transformers, filters) => {
     transform: transformDef = null,
     transformTo: transformToDef = null,
     filterFrom = null,
-    filterTo = null
+    filterTo = null,
   } = mapping
 
   const transformPipeline = preparePipeline(transformDef, transformers)
@@ -100,15 +136,19 @@ const createPipelines = (mapping, transformers, filters) => {
       transformers
     ).map(transformRev),
     filterFrom: preparePipeline(filterFrom, filters).map(filterFwd),
-    filterTo: preparePipeline(filterTo, filters).map(filterRev)
+    filterTo: preparePipeline(filterTo, filters).map(filterRev),
   }
 }
 
-const concatPipeline = (mapping, schema, { createPipelineFn, transformers, filters }) => {
+const concatPipeline = (
+  mapping,
+  schema,
+  { createPipelineFn, transformers, filters }
+) => {
   const pipelines = createPipelines(mapping, transformers, filters)
 
   return [
-    mapping.path,
+    ...pathToPipeline(mapping.path),
     ...prepareQualifier(mapping.qualifier),
     ...prepareTypeQualifier(mapping),
     prepareMapping(mapping, transformers, createPipelineFn),
@@ -117,7 +157,7 @@ const concatPipeline = (mapping, schema, { createPipelineFn, transformers, filte
     ...pipelines.transformRev,
     ...pipelines.filterFrom,
     ...pipelines.filterTo,
-    filter(item => typeof item !== 'undefined')
+    filter((item) => typeof item !== 'undefined'),
   ]
 }
 
@@ -133,7 +173,7 @@ const createPipeline = (filters, transformers, schemas, mappings) => {
     const pipeline = concatPipeline(mapping, schema, {
       createPipelineFn,
       transformers,
-      filters
+      filters,
     })
 
     return { id, type, schema, pipeline }
@@ -147,29 +187,33 @@ const createPipeline = (filters, transformers, schemas, mappings) => {
  * @param {Object} resources - filters, transformers, and schemas
  * @returns {Object} Item mapping def
  */
-function mapping ({
+function mapping({
   filters,
   transformers,
   schemas = {},
-  mappings: mappingsArr = []
+  mappings: mappingsArr = [],
 } = {}) {
   const mappings = mappingsArr.reduce(
     (mappings, def) => ({ ...mappings, [def.id]: def }),
     {}
   )
-  const createPipelineFn = createPipeline(filters, transformers, schemas, mappings)
+  const createPipelineFn = createPipeline(
+    filters,
+    transformers,
+    schemas,
+    mappings
+  )
 
   return (mapping, overrideType) => {
-    const { id, type, schema, pipeline } = createPipelineFn(mapping, overrideType)
+    const { id, type, schema, pipeline } = createPipelineFn(
+      mapping,
+      overrideType
+    )
     if (!pipeline) {
       return null
     }
 
-    const mapper = mapTransform([
-      fwd('data'),
-      ...pipeline,
-      rev(set('data'))
-    ])
+    const mapper = mapTransform([fwd('data'), ...pipeline, rev(set('data'))])
 
     return {
       id,
@@ -182,11 +226,11 @@ function mapping ({
        * @param {Object} options - onlyMappedValues
        * @returns {Object} Target item
        */
-      fromService (data, { onlyMappedValues = true } = {}) {
+      fromService(data, { onlyMappedValues = true } = {}) {
         return data
           ? ensureArray(
-            (onlyMappedValues) ? mapper.onlyMappedValues(data) : mapper(data)
-          )
+              onlyMappedValues ? mapper.onlyMappedValues(data) : mapper(data)
+            )
           : []
       },
 
@@ -196,7 +240,7 @@ function mapping ({
        * @param {Object} target - Optional object to map to data on
        * @returns {Object} Mapped data
        */
-      toService (data, target = null) {
+      toService(data, target = null) {
         const mapped = mapper.rev.onlyMappedValues(data)
         return (
           (target
@@ -205,7 +249,7 @@ function mapping ({
               : mergeDeepWith(concatOrRight, target, mapped)
             : mapped) || null
         )
-      }
+      },
     }
   }
 }

package/lib/mapping/normalize.js

@@ -1,45 +1,66 @@
 const { compose, map } = require('ramda')
 const is = require('@sindresorhus/is')
 const { transform, fwd, rev, value, fixed, set, alt } = require('map-transform')
-const { preparePipeline, prepareRevPipeline } = require('../utils/preparePipeline')
+const {
+  preparePipeline,
+  prepareRevPipeline,
+} = require('../utils/preparePipeline')
 
 const pathPipelineSetAlts = ([primary, ...alts]) => [
   primary,
-  ...alts.map(compose(fwd, alt))
+  ...alts.map(compose(fwd, alt)),
 ]
 
-const pathToPipeline = (path) => is.array(path)
-  ? pathPipelineSetAlts(path)
-  : [path]
+const pathToPipeline = (path) =>
+  is.array(path) ? pathPipelineSetAlts(path) : [path]
 
 const createSubMapping = (sub, transformers, switchTransforms) =>
-  (switchTransforms && typeof sub === 'string')
+  switchTransforms && typeof sub === 'string'
     ? set(sub)
     : normalizeFieldMapping(transformers, switchTransforms)(sub)
 
-const createFieldPipeline = ({
-  path,
-  transform: transformDef = [],
-  transformTo: transformToDef = null,
-  default: defValue,
-  const: constValue,
-  sub
-}, transformers, switchTransforms) => {
+const createFieldPipeline = (
+  {
+    path,
+    transform: transformDef = [],
+    transformTo: transformToDef = null,
+    default: defValue,
+    const: constValue,
+    sub,
+  },
+  transformers,
+  switchTransforms
+) => {
   const transformPipeline = preparePipeline(transformDef, transformers)
-  const revTransformPipeline = prepareRevPipeline(transformToDef, transformPipeline, transformers)
+  const revTransformPipeline = prepareRevPipeline(
+    transformToDef,
+    transformPipeline,
+    transformers
+  )
   return [
     ...pathToPipeline(path),
-    (typeof constValue !== 'undefined') ? fixed(constValue) : null,
-    (typeof defValue !== 'undefined') ? alt(value(defValue)) : null,
-    (sub && switchTransforms) ? createSubMapping(sub, transformers, switchTransforms) : null,
-    ...((switchTransforms) ? revTransformPipeline : transformPipeline).map(compose(fwd, transform)),
-    ...((switchTransforms) ? transformPipeline : revTransformPipeline).map(compose(rev, transform)),
-    (sub && !switchTransforms) ? createSubMapping(sub, transformers, switchTransforms) : null
+    typeof constValue !== 'undefined' ? fixed(constValue) : null,
+    typeof defValue !== 'undefined' ? alt(value(defValue)) : null,
+    sub && switchTransforms
+      ? createSubMapping(sub, transformers, switchTransforms)
+      : null,
+    ...(switchTransforms ? revTransformPipeline : transformPipeline).map(
+      compose(fwd, transform)
+    ),
+    ...(switchTransforms ? transformPipeline : revTransformPipeline).map(
+      compose(rev, transform)
+    ),
+    sub && !switchTransforms
+      ? createSubMapping(sub, transformers, switchTransforms)
+      : null,
   ].filter(Boolean)
 }
-const normalizeFieldMapping = (transformers = {}, switchTransforms = false) => (def) => (is.string(def) || is.array(def))
-  ? pathToPipeline(def)
-  : createFieldPipeline(def, transformers, switchTransforms)
+const normalizeFieldMapping =
+  (transformers = {}, switchTransforms = false) =>
+  (def) =>
+    is.string(def) || is.array(def)
+      ? pathToPipeline(def)
+      : createFieldPipeline(def, transformers, switchTransforms)
 
 const normalizeMapping = (mapping, transformers = {}) =>
   map(normalizeFieldMapping(transformers), mapping)
@@ -50,5 +71,6 @@ const normalizeMappingWithSwitchedTransforms = (mapping, transformers = {}) =>
 module.exports = {
   normalizeMapping,
   normalizeFieldMapping,
-  normalizeMappingWithSwitchedTransforms
+  normalizeMappingWithSwitchedTransforms,
+  pathToPipeline,
 }

package/lib/queue/enqueue.js

@@ -3,30 +3,41 @@ const createError = require('../utils/createError')
 
 const prepareMetaForQueue = ({ queue, ...rest }) => ({
   ...rest,
-  queuedAt: Date.now()
+  queuedAt: Date.now(),
 })
 
 const prepareForQueue = (action) => ({
   ...action,
-  meta: prepareMetaForQueue(action.meta)
+  meta: prepareMetaForQueue(action.meta),
 })
 
 const enqueue = async (queue, action) => {
   const { meta } = action
   const queuedAction = prepareForQueue(action)
-  const timestamp = (typeof meta.queue === 'boolean') ? null : meta.queue
+  const timestamp = typeof meta.queue === 'boolean' ? null : meta.queue
   const actionId = meta.id || null
 
   let id
   try {
     id = await queue.push(queuedAction, timestamp, actionId)
   } catch (error) {
-    debug('Error from queue when pushing %o with timestamp %s. Error: %s', queuedAction, timestamp, error)
+    debug(
+      'Error from queue when pushing %o with timestamp %s. Error: %s',
+      queuedAction,
+      timestamp,
+      error
+    )
     return createError(`Could not push to queue. ${error}`)
   }
 
-  debug('Pushed to queue with timestamp %s and id \'%s\': %o', timestamp, id, queuedAction)
-  return { status: 'queued', data: { id } }
+  debug(
+    "Pushed to queue with timestamp %s and id '%s': %o",
+    timestamp,
+    id,
+    queuedAction
+  )
+  const queuedStatus = action.meta.queuedStatus || 'queued'
+  return { status: queuedStatus, data: { id } }
 }
 
 module.exports = enqueue

package/lib/queue/middleware.js

@@ -17,12 +17,15 @@ const enqueueNext = (queue, action) => {
   const nextTime = getNextTime(action)
 
   if (nextTime) {
-    const nextAction = { ...action, meta: { ...action.meta, queue: nextTime.getTime() } }
+    const nextAction = {
+      ...action,
+      meta: { ...action.meta, queue: nextTime.getTime() },
+    }
     return enqueue(queue, nextAction)
   }
 }
 
-function middleware (next, queue) {
+function middleware(next, queue) {
   return async (action) => {
     if (action.meta && action.meta.queue) {
       return enqueue(queue, action)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "integreat",
-  "version": "0.7.33",
+  "version": "0.7.37",
   "description": "Node.js integration layer",
   "author": "Kjell-Morten Bratsberg Thorsen <post@kjellmorten.no> (http://kjellmorten.no/)",
   "license": "ISC",
@@ -13,12 +13,11 @@
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "test": "npm run lint && NODE_ENV=test nyc --reporter=text-summary ava",
+    "test": "NODE_ENV=test nyc --reporter=text-summary ava",
     "test:inspect": "node --inspect node_modules/ava/profile.js",
     "dev": "NODE_ENV=test ava --watch",
     "coverage": "nyc report --reporter=text-lcov | coveralls",
-    "nyc:report": "nyc report --reporter=text --reporter=html",
-    "lint": "standard"
+    "nyc:report": "nyc report --reporter=text --reporter=html"
   },
   "ava": {
     "babel": true,
@@ -47,24 +46,25 @@
   },
   "dependencies": {
     "@sindresorhus/is": "^1.2.0",
-    "debug": "^4.3.2",
+    "debug": "^4.3.3",
     "got": "^9.6.0",
     "later": "^1.2.0",
     "map-any": "^0.2.1",
-    "map-transform": "^0.3.11",
+    "map-transform": "^0.3.12",
     "p-limit": "^2.3.0",
+    "p-progress": "^0.5.1",
     "ramda": "^0.27.1",
     "uuid": "^3.4.0"
   },
   "devDependencies": {
-    "@ava/babel": "^1.0.1",
-    "ava": "3.3.0",
-    "coveralls": "^3.1.0",
-    "dotenv": "^8.2.0",
+    "@ava/babel": "^2.0.0",
+    "ava": "3.15.0",
+    "coveralls": "^3.1.1",
+    "dotenv": "^10.0.0",
     "integreat-adapter-json": "^0.2.1",
-    "nock": "^12.0.3",
+    "nock": "^13.2.1",
     "nyc": "^15.1.0",
-    "sinon": "^9.2.4",
-    "standard": "^14.3.4"
+    "prettier": "^2.5.1",
+    "sinon": "^11.1.2"
   }
 }