integreat 0.7.35 → 0.7.39

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 | number
+    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/actions/sync.js

@@ -267,21 +267,15 @@ async function transformData(
   useIndividualTransform
 ) {
   if (useIndividualTransform) {
-    const responses = await Promise.all(
+    return await Promise.all(
       data
         .map((item) =>
           dispatch(createTransformAction(transformParams, item, meta))
         )
         .map((p) => pLimit(1)(() => p))
     )
-    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
+    return [await dispatch(createTransformAction(transformParams, data, meta))]
   }
 }
 
@@ -344,7 +338,7 @@ async function sync({ payload, meta = {} }, { dispatch, getService }) {
 
   // Dispatch transform action
   if (transformParams) {
-    data = await transformData(
+    const transformResults = await transformData(
       data,
       dispatch,
       transformParams,
@@ -352,6 +346,16 @@ async function sync({ payload, meta = {} }, { dispatch, getService }) {
       payload.useIndividualTransform
     )
 
+    if (transformResults.some((result) => result.status !== 'ok')) {
+      return transformResults.length === 1
+        ? transformResults[0]
+        : createError(makeErrorString(transformResults))
+    }
+
+    data = flatten(transformResults.map((result) => result.data)).filter(
+      Boolean
+    )
+
     if (data.length === 0 && payload.syncNoData !== true) {
       return createError(
         `No items to update from service '${fromParams[0].service}' after transform action`,

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.35'
+const version = '0.7.39'
 
 /**
  * Return an Integreat instance with a dispatch method.

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/authenticate.js

@@ -2,8 +2,8 @@ const is = require('@sindresorhus/is')
 
 const generateErrorResponse = (status, error, access, authError) => ({
   status,
-  error: (authError) ? `${error}: ${authError}` : error,
-  access: { ...access, status: 'refused', scheme: 'service' }
+  error: authError ? `${error}: ${authError}` : error,
+  access: { ...access, status: 'refused', scheme: 'service' },
 })
 
 const responseFromAuthentication = (authentication, response, { access }) => {
@@ -11,18 +11,38 @@ const responseFromAuthentication = (authentication, response, { access }) => {
     case 'granted':
       return undefined
     case 'refused':
-      return generateErrorResponse('noaccess', 'Authentication was refused', access)
+      return generateErrorResponse(
+        'noaccess',
+        'Authentication was refused',
+        access
+      )
     case 'error':
     case 'timeout':
-      return generateErrorResponse('autherror', 'Could not authenticate', access, authentication.error)
+      return generateErrorResponse(
+        'autherror',
+        'Could not authenticate',
+        access,
+        authentication.error
+      )
   }
 
-  return generateErrorResponse('autherror', 'Could not authenticate - unknown status from authenticator', access)
+  return generateErrorResponse(
+    'autherror',
+    'Could not authenticate - unknown status from authenticator',
+    access
+  )
 }
 
-const requestFromAuthentication = (authentication, authenticator, adapter, request) => {
+const requestFromAuthentication = (
+  authentication,
+  authenticator,
+  adapter,
+  request,
+  authOptions
+) => {
   if (authentication.status === 'granted') {
-    const fn = authenticator[adapter.authentication]
+    const method = authOptions.overrideAdapterMethod || adapter.authentication
+    const fn = authenticator[method]
     if (is.function(fn)) {
       const auth = fn(authentication)
       return { ...request, auth }
@@ -32,7 +52,12 @@ const requestFromAuthentication = (authentication, authenticator, adapter, reque
   return { ...request, auth: null }
 }
 
-const doAuthenticate = async (authenticator, authOptions, request, retries = 1) => {
+const doAuthenticate = async (
+  authenticator,
+  authOptions,
+  request,
+  retries = 1
+) => {
   const authentication = await authenticator.authenticate(authOptions, request)
 
   if (authentication.status === 'timeout' && retries > 0) {
@@ -42,28 +67,53 @@ const doAuthenticate = async (authenticator, authOptions, request, retries = 1)
   return authentication
 }
 
-function authenticate ({ authenticator, authOptions, setAuthentication = () => {}, adapter }) {
-  return (authenticator && authenticator.authenticate)
+function authenticate({
+  authenticator,
+  authOptions,
+  setAuthentication = () => {},
+  adapter,
+}) {
+  return authenticator && authenticator.authenticate
     ? async (args) => {
-      const { authentication, response, request } = args
+        const { authentication, response, request } = args
 
-      if (authentication && authenticator.isAuthenticated(authentication)) {
-        return {
-          ...args,
-          request: requestFromAuthentication(authentication, authenticator, adapter, request)
+        if (authentication && authenticator.isAuthenticated(authentication)) {
+          return {
+            ...args,
+            request: requestFromAuthentication(
+              authentication,
+              authenticator,
+              adapter,
+              request,
+              authOptions
+            ),
+          }
         }
-      }
 
-      const nextAuthentication = await doAuthenticate(authenticator, authOptions, request)
-      setAuthentication(nextAuthentication)
+        const nextAuthentication = await doAuthenticate(
+          authenticator,
+          authOptions,
+          request
+        )
+        setAuthentication(nextAuthentication)
 
-      return {
-        ...args,
-        authentication: nextAuthentication,
-        response: responseFromAuthentication(nextAuthentication, response, request),
-        request: requestFromAuthentication(nextAuthentication, authenticator, adapter, request)
+        return {
+          ...args,
+          authentication: nextAuthentication,
+          response: responseFromAuthentication(
+            nextAuthentication,
+            response,
+            request
+          ),
+          request: requestFromAuthentication(
+            nextAuthentication,
+            authenticator,
+            adapter,
+            request,
+            authOptions
+          ),
+        }
       }
-    }
     : async (args) => args
 }
 

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/lib/service/requestFromAction.js

@@ -6,9 +6,9 @@ const getPluralType = (type, schemas) =>
  * @param {Object} request - The request object to complete
  * @returns {Object} The completed request object
  */
-function requestFromAction (
+function requestFromAction(
   { type: action, payload, meta = {} },
-  { endpoint, schemas = {} } = {}
+  { endpoint, schemas = {}, auth } = {}
 ) {
   const { data, ...params } = payload
   const { ident = null, id } = meta
@@ -19,11 +19,12 @@ function requestFromAction (
     params,
     data,
     endpoint: (endpoint && endpoint.options) || null,
+    auth,
     access: { ident },
     meta: {
       id,
-      typePlural
-    }
+      typePlural,
+    },
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "integreat",
-  "version": "0.7.35",
+  "version": "0.7.39",
   "description": "Node.js integration layer",
   "author": "Kjell-Morten Bratsberg Thorsen <post@kjellmorten.no> (http://kjellmorten.no/)",
   "license": "ISC",
@@ -46,13 +46,14 @@
   },
   "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",
-    "ramda": "^0.27.1",
+    "p-progress": "^0.5.1",
+    "ramda": "^0.27.2",
     "uuid": "^3.4.0"
   },
   "devDependencies": {
@@ -61,9 +62,9 @@
     "coveralls": "^3.1.1",
     "dotenv": "^10.0.0",
     "integreat-adapter-json": "^0.2.1",
-    "nock": "^13.1.2",
+    "nock": "^13.2.4",
     "nyc": "^15.1.0",
-    "prettier": "^2.3.2",
+    "prettier": "^2.5.1",
     "sinon": "^11.1.2"
   }
 }