integreat 0.7.34 → 0.7.38

package/index.d.ts

@@ -1,7 +1,7 @@
 export as namespace integreat
 export = integreat
 
-declare function integreat (
+declare function integreat(
   defs: integreat.Definitions,
   resources: integreat.Resources,
   middlewares?: integreat.Middleware[]
@@ -20,58 +20,63 @@ declare namespace integreat {
   }
 
   export interface Ident {
-    id?: string,
+    id?: string
     root?: boolean
   }
 
   export interface Meta {
-    queue?: boolean,
-    ident?: Ident,
+    queue?: boolean
+    ident?: Ident
     [key: string]: unknown
   }
 
   export interface Action<P = Payload> {
-    type: string,
-    payload: P,
+    type: string
+    payload: P
     meta?: Meta
   }
 
   export type ActionHandlerResources = {
     dispatch: Dispatch
+    setProgress: (progress: number) => void
   }
 
   export interface Instance {
-    version: string,
-    schemas: object,
-    services: object,
-    identType: string,
+    version: string
+    schemas: object
+    services: object
+    identType: string
 
-    dispatch: Dispatch,
-    on: (eventName: string, serviceId: string, listener: (request: Request, response: Response) => void) => void
+    dispatch: Dispatch
+    on: (
+      eventName: string,
+      serviceId: string,
+      listener: (request: Request, response: Response) => void
+    ) => void
   }
 
   export interface IdentDefinitions {
     type: string
     props?: {
-      id?: string,
-      roles?: string,
+      id?: string
+      roles?: string
       tokens?: string
     }
   }
 
   export interface Definitions {
-    schemas: object[],
-    services: object[],
-    mappings: object[],
-    auths?: object[],
+    schemas: object[]
+    services: object[]
+    mappings: object[]
+    auths?: object[]
     ident?: IdentDefinitions
   }
 
   export interface Resources {
-    adapters: any,
-    authenticators?: any,
-    transformers?: any,
-    filters?: any,
+    adapters: any
+    authenticators?: any
+    transformers?: any
+    filters?: any
     actions?: any
   }
 
@@ -80,9 +85,9 @@ declare namespace integreat {
   }
 
   export interface Queue {
-    queue: object,
-    setDispatch: (dispatch: Dispatch) => Promise<void>,
-    middleware: Middleware,
+    queue: object
+    setDispatch: (dispatch: Dispatch) => Promise<void>
+    middleware: Middleware
     schedule: (schedule: object) => Promise<Response>
   }
 
@@ -97,10 +102,10 @@ declare namespace integreat {
   }
 
   type Relationship = {
-    id: string | null | undefined,
-    type: string,
-    attributes?: Attributes,
-    relationships?: Relationships,
+    id: string | null | undefined
+    type: string
+    attributes?: Attributes
+    relationships?: Relationships
     meta?: object
   }
 
@@ -109,30 +114,30 @@ declare namespace integreat {
   }
 
   export type Data = {
-    id: string | null | undefined,
-    type: string,
-    attributes: Attributes,
+    id: string | null | undefined
+    type: string
+    attributes: Attributes
     relationships: Relationships
   }
 
   interface Request<T = Data[] | Data | null> {
-    action: string,
+    action: string
     params?: {
       [param: string]: any
-    },
+    }
     endpoint?: {
       [option: string]: any
     }
-    data: T,
-    auth?: object | boolean,
+    data: T
+    auth?: object | boolean
     access?: { ident: Ident }
   }
 
   interface Response<T = Data[]> {
-    status: string,
-    data?: T,
-    error?: string,
-    responses?: Response[],
+    status: string
+    data?: T
+    error?: string
+    responses?: Response[]
     access?: object
   }
 }

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.38'
 
 /**
  * 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/lib/service/mapFromService.js

@@ -5,13 +5,19 @@ const mergeWithParams = (response, params) => ({
   ...response,
   params: {
     ...params,
-    ...response.params
-  }
+    ...response.params,
+  },
 })
 
 const mapWithEndpoint = (responseMapper, response, params, actionType) => {
-  if (responseMapper || actionType.startsWith('GET') || actionType === 'REQUEST') {
-    return (responseMapper) ? responseMapper(mergeWithParams(response, params)) || {} : response
+  if (
+    responseMapper ||
+    actionType.startsWith('GET') ||
+    actionType === 'REQUEST'
+  ) {
+    return responseMapper
+      ? responseMapper(mergeWithParams(response, params)) || {}
+      : response
   } else {
     return {}
   }
@@ -25,8 +31,14 @@ const mapWithEndpoint = (responseMapper, response, params, actionType) => {
  * @param {Object} options - mappings, params, onlyMappedValues, and endpoint
  * @returns {Object[]} Array of mapped items
  */
-function mapFromService () {
-  return ({ response, request, responseMapper, mappings, mapResponseWithType = true }) => {
+function mapFromService() {
+  return ({
+    response,
+    request,
+    responseMapper,
+    mappings,
+    mapResponseWithType = true,
+  }) => {
     const type = request.params.type || Object.keys(mappings)
     const { onlyMappedValues, unmapped = false } = request.params
 
@@ -34,28 +46,38 @@ function mapFromService () {
       return response
     }
 
-    const {
-      data,
-      status = response.status,
-      error,
-      paging,
-      params
-    } = mapWithEndpoint(responseMapper, response, request.params, request.action)
+    const { data, status, error, paging, params } = mapWithEndpoint(
+      responseMapper,
+      response,
+      request.params,
+      request.action
+    )
+
     const responseError = [response.error, error].filter(Boolean).join(' | ')
+    const responseStatus =
+      response.status !== 'ok'
+        ? response.status
+        : status || (responseError ? 'error' : 'ok')
 
     const ret = {
       ...response,
-      status: response.status === 'ok' ? status : response.status,
-      ...(status !== 'ok' && responseError ? { error: responseError } : {}),
-      ...((paging) ? { paging } : {}),
-      ...((params) ? { params } : {}),
-      ...(status === 'ok' || data ? { data: data === null ? undefined : data } : {})
+      status: responseStatus,
+      ...(responseError ? { error: responseError } : {}),
+      ...(paging ? { paging } : {}),
+      ...(params ? { params } : {}),
+      ...(responseStatus === 'ok' || data
+        ? { data: data === null ? undefined : data }
+        : {}),
     }
 
-    if (status === 'ok' && data && mapResponseWithType) {
-      const mapType = (type) => (mappings[type])
-        ? mappings[type].fromService({ ...request, data }, { onlyMappedValues })
-        : []
+    if (ret.status === 'ok' && data && mapResponseWithType) {
+      const mapType = (type) =>
+        mappings[type]
+          ? mappings[type].fromService(
+              { ...request, data },
+              { onlyMappedValues }
+            )
+          : []
       ret.data = flatten(mapAny(mapType, type))
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "integreat",
-  "version": "0.7.34",
+  "version": "0.7.38",
   "description": "Node.js integration layer",
   "author": "Kjell-Morten Bratsberg Thorsen <post@kjellmorten.no> (http://kjellmorten.no/)",
   "license": "ISC",
@@ -46,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.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.6.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",
-    "prettier": "^2.3.1",
-    "sinon": "^9.2.4"
+    "prettier": "^2.5.1",
+    "sinon": "^11.1.2"
   }
 }