integreat 0.7.44 → 0.7.46

package/lib/integreat.js

@@ -5,7 +5,7 @@ const setupMapping = require('./mapping')
 const setupDispatch = require('./dispatch')
 const builtinActions = require('./actions')
 
-const version = '0.7.44'
+const version = '0.7.46'
 
 /**
  * Return an Integreat instance with a dispatch method.

package/lib/service/index.js

@@ -2,51 +2,72 @@ const EventEmitter = require('events')
 const { compose, identity } = require('ramda')
 const prepareEndpoints = require('../endpoints')
 const requestFromAction = require('./requestFromAction')
-const { beforeService, sendToService, afterService, respondToUnknownAction } = require('./send')
+const {
+  beforeService,
+  sendToService,
+  afterService,
+  respondToUnknownAction,
+} = require('./send')
 const createError = require('../utils/createError')
 
-const lookup = (id, resource) => (typeof id === 'string') ? resource[id] : id
+const lookup = (id, resource) => (typeof id === 'string' ? resource[id] : id)
 
 const normalizeAction = async (action, adapter) => {
-  const normalized = await adapter.normalize({ status: 'ok', data: action.payload.data }, { endpoint: {} })
+  const normalized = await adapter.normalize(
+    { status: 'ok', data: action.payload.data },
+    { endpoint: {} }
+  )
   return { ...action, payload: { ...action.payload, data: normalized.data } }
 }
 
-const receiveRequestFromAction = ({ type, payload: { data, ...params }, meta: { ident } }, endpoint) =>
-  ({
-    action: type,
-    params: {
-      ...endpoint.options.actionPayload,
-      ...params
-    },
-    endpoint: endpoint.options,
-    access: { ident }
-  })
+const receiveRequestFromAction = (
+  { type, payload: { data, ...params }, meta: { ident } },
+  endpoint
+) => ({
+  action: type,
+  params: {
+    ...endpoint.options.actionPayload,
+    ...params,
+  },
+  endpoint: endpoint.options,
+  access: { ident },
+})
 
 const receiveAfterArgs = (action, request, endpoint) => ({
   request,
-  response: ({ status: 'ok', data: action.payload.data }),
+  response: { status: 'ok', data: action.payload.data },
   requestMapper: endpoint.requestMapper,
   responseMapper: endpoint.responseMapper,
-  mappings: endpoint.mappings
+  mappings: endpoint.mappings,
 })
 
-const receiveBeforeArgs = ({ data, status, error }, request, { payload: { data: _, ...params } }, endpoint) => ({
-  request: { ...request, data, params: { ...request.params, ...params, status, error } },
+const receiveBeforeArgs = (
+  { data, status, error },
+  request,
+  { payload: { data: _, ...params } },
+  endpoint
+) => ({
+  request: {
+    ...request,
+    data,
+    params: { ...request.params, ...params, status, error },
+  },
   requestMapper: endpoint.requestMapper,
   responseMapper: endpoint.responseMapper,
-  mappings: endpoint.mappings
+  mappings: endpoint.mappings,
 })
 
+const removeIdAndSetGid = ({ id, ...meta }) => ({ ...meta, gid: id })
+
 const createNextAction = (action, { options }, mappedResponse) => ({
   type: options.actionType,
   payload: {
     type: action.payload.type,
     ...options.actionPayload,
     ...mappedResponse.params,
-    ...((mappedResponse.data) ? { data: mappedResponse.data } : {})
+    ...(mappedResponse.data ? { data: mappedResponse.data } : {}),
   },
-  meta: { ...action.meta, ...options.actionMeta }
+  meta: removeIdAndSetGid({ ...action.meta, ...options.actionMeta }),
 })
 
 const wrapResponse = (response) => ({ response })
@@ -57,145 +78,175 @@ const wrapResponse = (response) => ({ response })
  * @param {Object} resources - Object with mappings, adapters, auths, and plurals
  * @returns {Object} The created service
  */
-const service = ({
-  adapters = {},
-  auths = {},
-  transformers = {},
-  schemas,
-  setupMapping = identity
-} = {}) => ({
-  id: serviceId,
-  adapter,
-  auth = null,
-  meta = null,
-  options = {},
-  endpoints = [],
-  mappings: mappingsDef = {}
-}) => {
-  if (!serviceId) {
-    throw new TypeError('Can\'t create service without an id.')
-  }
-
-  adapter = lookup(adapter, adapters)
-  if (!adapter) {
-    throw new TypeError(`Can't create service '${serviceId}' without an adapter.`)
-  }
-
-  endpoints = prepareEndpoints({ endpoints, options, mappings: mappingsDef }, { adapter, transformers, setupMapping })
-  auth = lookup(auth, auths) || {}
-  let connection = null
-  const emitter = new EventEmitter()
-
-  const sendOptions = {
-    serviceId,
+const service =
+  ({
+    adapters = {},
+    auths = {},
+    transformers = {},
     schemas,
+    setupMapping = identity,
+  } = {}) =>
+  ({
+    id: serviceId,
     adapter,
-    authenticator: auth.authenticator,
-    authOptions: auth.options,
-    setAuthentication: (authentication) => { auth.authentication = authentication },
-    setConnection: (conn) => { connection = conn },
-    serviceOptions: options,
-    emit: emitter.emit.bind(emitter)
-  }
+    auth = null,
+    meta = null,
+    options = {},
+    endpoints = [],
+    mappings: mappingsDef = {},
+  }) => {
+    if (!serviceId) {
+      throw new TypeError("Can't create service without an id.")
+    }
 
-  const beforeServiceFn = beforeService(sendOptions)
-  const afterServiceFn = afterService(sendOptions)
+    adapter = lookup(adapter, adapters)
+    if (!adapter) {
+      throw new TypeError(
+        `Can't create service '${serviceId}' without an adapter.`
+      )
+    }
 
-  const sendFn = compose(
-    afterServiceFn,
-    sendToService(sendOptions),
-    beforeServiceFn,
-    respondToUnknownAction(sendOptions)
-  )
+    endpoints = prepareEndpoints(
+      { endpoints, options, mappings: mappingsDef },
+      { adapter, transformers, setupMapping }
+    )
+    auth = lookup(auth, auths) || {}
+    let connection = null
+    const emitter = new EventEmitter()
+
+    const sendOptions = {
+      serviceId,
+      schemas,
+      adapter,
+      authenticator: auth.authenticator,
+      authOptions: auth.options,
+      setAuthentication: (authentication) => {
+        auth.authentication = authentication
+      },
+      setConnection: (conn) => {
+        connection = conn
+      },
+      serviceOptions: options,
+      emit: emitter.emit.bind(emitter),
+    }
 
-  // Create the service instance
-  return {
-    id: serviceId,
-    adapter,
-    meta,
-    endpoints: endpoints.list,
-    on: emitter.on.bind(emitter),
-
-    /**
-     * The given action is prepared, authenticated, and mapped, before it is
-     * sent to the service via the adapter. The response from the adapter is then
-     * mapped, authenticated, and returned.
-     *
-     * The prepared and authenticated request is also returned.
-     *
-     * @param {Object} action - Action object to map and send to the service
-     * @returns {Object} Object with the sent request and the received response
-     */
-    async send (action) {
-      const endpoint = endpoints.match(action)
-      if (!endpoint) {
-        return { response: createError(`No endpoint matching request to service '${serviceId}'.`, 'noaction') }
-      }
-
-      const validateRes = endpoint.validate(action)
-      if (validateRes !== null) {
-        return { response: validateRes }
-      }
-
-      const {
-        requestMapper,
-        responseMapper,
-        mapResponseWithType = true,
-        mappings
-      } = endpoint
-
-      return sendFn({
-        request: requestFromAction(action, { endpoint, schemas }),
-        authentication: auth.authentication,
-        requestMapper,
-        responseMapper,
-        mapResponseWithType,
-        mappings,
-        connection
-      })
-    },
-
-    /**
-     * The given action is prepared, authenticated, and mapped – as coming
-     * _from_ the service. It is then made into an action and dispatched.
-     * The response from the action is mapped, authenticated, and returned – for
-     * going _to_ the service.
-     *
-     * @param {Object} action - Action object to map from the service
-     * @param {Object} dispatch - A dispatch function
-     * @returns {Object} Object with the received response
-     */
-    async receive (action, dispatch) {
-      action = await normalizeAction(action, adapter)
-      const endpoint = endpoints.match(action)
-      if (!endpoint) {
-        return wrapResponse(createError(`No endpoint matching request to service '${serviceId}'.`, 'noaction'))
-      }
-
-      const validateRes = endpoint.validate(action)
-      if (validateRes !== null) {
-        return wrapResponse(validateRes)
-      }
-
-      if (!endpoint.options || !endpoint.options.actionType) {
-        return wrapResponse(createError(`The matching endpoint on service '${serviceId}' did not specify an action type`, 'noaction'))
-      }
-
-      const request = receiveRequestFromAction(action, endpoint)
-      const mapped = await afterServiceFn(receiveAfterArgs(action, request, endpoint))
-      const nextAction = createNextAction(action, endpoint, mapped.response)
-
-      const response = await dispatch(nextAction)
-
-      const serialized = await beforeServiceFn(receiveBeforeArgs(response, request, nextAction, endpoint))
-
-      return wrapResponse({
-        ...response,
-        ...((serialized.request.data) ? { data: serialized.request.data } : {}),
-        access: serialized.request.access
-      })
+    const beforeServiceFn = beforeService(sendOptions)
+    const afterServiceFn = afterService(sendOptions)
+
+    const sendFn = compose(
+      afterServiceFn,
+      sendToService(sendOptions),
+      beforeServiceFn,
+      respondToUnknownAction(sendOptions)
+    )
+
+    // Create the service instance
+    return {
+      id: serviceId,
+      adapter,
+      meta,
+      endpoints: endpoints.list,
+      on: emitter.on.bind(emitter),
+
+      /**
+       * The given action is prepared, authenticated, and mapped, before it is
+       * sent to the service via the adapter. The response from the adapter is then
+       * mapped, authenticated, and returned.
+       *
+       * The prepared and authenticated request is also returned.
+       *
+       * @param {Object} action - Action object to map and send to the service
+       * @returns {Object} Object with the sent request and the received response
+       */
+      async send(action) {
+        const endpoint = endpoints.match(action)
+        if (!endpoint) {
+          return {
+            response: createError(
+              `No endpoint matching request to service '${serviceId}'.`,
+              'noaction'
+            ),
+          }
+        }
+
+        const validateRes = endpoint.validate(action)
+        if (validateRes !== null) {
+          return { response: validateRes }
+        }
+
+        const {
+          requestMapper,
+          responseMapper,
+          mapResponseWithType = true,
+          mappings,
+        } = endpoint
+
+        return sendFn({
+          request: requestFromAction(action, { endpoint, schemas }),
+          authentication: auth.authentication,
+          requestMapper,
+          responseMapper,
+          mapResponseWithType,
+          mappings,
+          connection,
+        })
+      },
+
+      /**
+       * The given action is prepared, authenticated, and mapped – as coming
+       * _from_ the service. It is then made into an action and dispatched.
+       * The response from the action is mapped, authenticated, and returned – for
+       * going _to_ the service.
+       *
+       * @param {Object} action - Action object to map from the service
+       * @param {Object} dispatch - A dispatch function
+       * @returns {Object} Object with the received response
+       */
+      async receive(action, dispatch) {
+        action = await normalizeAction(action, adapter)
+        const endpoint = endpoints.match(action)
+        if (!endpoint) {
+          return wrapResponse(
+            createError(
+              `No endpoint matching request to service '${serviceId}'.`,
+              'noaction'
+            )
+          )
+        }
+
+        const validateRes = endpoint.validate(action)
+        if (validateRes !== null) {
+          return wrapResponse(validateRes)
+        }
+
+        if (!endpoint.options || !endpoint.options.actionType) {
+          return wrapResponse(
+            createError(
+              `The matching endpoint on service '${serviceId}' did not specify an action type`,
+              'noaction'
+            )
+          )
+        }
+
+        const request = receiveRequestFromAction(action, endpoint)
+        const mapped = await afterServiceFn(
+          receiveAfterArgs(action, request, endpoint)
+        )
+        const nextAction = createNextAction(action, endpoint, mapped.response)
+
+        const response = await dispatch(nextAction)
+
+        const serialized = await beforeServiceFn(
+          receiveBeforeArgs(response, request, nextAction, endpoint)
+        )
+
+        return wrapResponse({
+          ...response,
+          ...(serialized.request.data ? { data: serialized.request.data } : {}),
+          access: serialized.request.access,
+        })
+      },
     }
   }
-}
 
 module.exports = service

package/lib/service/requestFromAction.js

@@ -11,7 +11,7 @@ function requestFromAction(
   { endpoint, schemas = {}, auth } = {}
 ) {
   const { data, ...params } = payload
-  const { ident = null, id } = meta
+  const { ident = null, id, cid, gid } = meta
   const typePlural = getPluralType(params.type, schemas)
 
   return {
@@ -23,6 +23,8 @@ function requestFromAction(
     access: { ident },
     meta: {
       id,
+      cid,
+      gid,
       typePlural,
     },
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "integreat",
-  "version": "0.7.44",
+  "version": "0.7.46",
   "description": "Node.js integration layer",
   "author": "Kjell-Morten Bratsberg Thorsen <post@kjellmorten.no> (http://kjellmorten.no/)",
   "license": "ISC",
@@ -46,12 +46,12 @@
   },
   "dependencies": {
     "@sindresorhus/is": "^1.2.0",
-    "debug": "^4.3.7",
+    "debug": "^4.4.0",
     "got": "^9.6.0",
     "later": "^1.2.0",
     "map-any": "^0.2.1",
     "map-transform": "^0.3.12",
-    "nanoid": "^3.3.7",
+    "nanoid": "^3.3.11",
     "p-limit": "^2.3.0",
     "p-progress": "^0.5.1",
     "ramda": "^0.27.2",