Add convenience functions for createRequest (#114)

* Add convenience functions for createRequest

* Version bump: 5.7.0

Author: dpikt

docs.md

@@ -218,6 +218,8 @@ function fooAction () {
 
 A function that creates action creators for making API requests, much like [createAction][43] from `redux-actions`.
 
+Note: there are convenience functions for each request method: `createPostRequest()`, `createPutRequest()`, etc.
+
 ### Parameters
 
 -   `type` **[String][41]** A unique key that will be used to identify the request internally in redux

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@launchpadlab/lp-redux-api",
-  "version": "5.6.2",
+  "version": "5.7.0",
   "description": "redux middleware and api library",
   "main": "lib/index.js",
   "scripts": {

src/create-request.js

@@ -5,6 +5,8 @@ import { isObject, isFunction } from 'lodash'
 /**
  * A function that creates action creators for making API requests, much like [createAction](https://redux-actions.js.org/api-reference/createaction-s) from `redux-actions`.
  *
+ * Note: there are convenience functions for each request method: `createPostRequest()`, `createPutRequest()`, etc.
+ *
  * @name createRequest
  * @param {String} type - A unique key that will be used to identify the request internally in redux
  * @param {Object|Function} definition - An object of `lp-request` config options, or a function that returns config options.
@@ -33,13 +35,14 @@ function createActionOptions (definition, args) {
     : definition
 }
 
-function createRequest (type, definition) {
+function createRequestWithMethod (type, definition, method) {
   if (!type) throw new Error('Must include a type for your request.')
   if (!definition) throw new Error('Must include a request definition for your request.')
   if (!(isObject(definition) || isFunction(definition))) throw new Error('Request definition must be an object or a function.')
   function actionCreator (...args) {
     return {
       [LP_API]: {
+        method,
         ...createActionOptions(definition, args),
         requestKey: type,
       }
@@ -49,4 +52,27 @@ function createRequest (type, definition) {
   return actionCreator
 }
 
-export default createRequest
+
+export function createRequest (type, definition) {
+  return createRequestWithMethod(type, definition, 'GET')
+}
+
+// Export convenience function for each request method
+
+export const createGetRequest = createRequest
+
+export function createPostRequest (type, definition) {
+  return createRequestWithMethod(type, definition, 'POST')
+}
+
+export function createPutRequest (type, definition) {
+  return createRequestWithMethod(type, definition, 'PUT')
+}
+
+export function createPatchRequest (type, definition) {
+  return createRequestWithMethod(type, definition, 'PATCH')
+}
+
+export function createDeleteRequest (type, definition) {
+  return createRequestWithMethod(type, definition, 'DELETE')
+}

src/index.js

@@ -5,7 +5,14 @@ export {
 } from './actions'
 export * from './handlers'
 export { default as LP_API } from './LP_API'
-export { default as createRequest } from './create-request'
+export { 
+  createRequest,
+  createGetRequest,
+  createPostRequest,
+  createPutRequest,
+  createPatchRequest,
+  createDeleteRequest,
+} from './create-request'
 export { default as middleware } from './middleware'
 export { default as reducer } from './reducer'
 export { default as requestWithKey } from './request-with-key'

test/create-request.test.js

@@ -1,4 +1,12 @@
-import { createRequest, LP_API } from '../src/'
+import {
+  LP_API,
+  createRequest,
+  createGetRequest,
+  createPostRequest,
+  createPutRequest,
+  createPatchRequest,
+  createDeleteRequest,
+} from '../src/'
 import { REQUEST_TYPE } from './fixtures'
 
 test('createRequest requires a type argument', () => {
@@ -13,17 +21,49 @@ test('createRequest accepts object request definitions', () => {
   const options = { foo: 'bar' }
   const actionCreator = createRequest(REQUEST_TYPE, options)
   const action = actionCreator()
-  expect(action[LP_API]).toEqual({ requestKey: REQUEST_TYPE, foo: 'bar' })
+  expect(action[LP_API]).toEqual({ requestKey: REQUEST_TYPE, foo: 'bar', method: 'GET' })
 })
 
 test('createRequest accepts function request definitions', () => {
   const actionCreator = createRequest(REQUEST_TYPE, (arg) => ({
     foo: arg
   }))
   const action = actionCreator('bar')
-  expect(action[LP_API]).toEqual({ requestKey: REQUEST_TYPE, foo: 'bar' })
+  expect(action[LP_API]).toEqual({ requestKey: REQUEST_TYPE, foo: 'bar', method: 'GET' })
 })
 
 test('createRequest rejects other types of request definitions', () => {
   expect(() => createRequest(REQUEST_TYPE, 'wtf')).toThrow()
 })
+
+// Convenience functions
+
+test('createGetRequest creates a request with method GET', () => {
+  const actionCreator = createGetRequest(REQUEST_TYPE, {})
+  const action = actionCreator()
+  expect(action[LP_API].method).toEqual('GET')
+})
+
+test('createPostRequest creates a request with method POST', () => {
+  const actionCreator = createPostRequest(REQUEST_TYPE, {})
+  const action = actionCreator()
+  expect(action[LP_API].method).toEqual('POST')
+})
+
+test('createPutRequest creates a request with method PUT', () => {
+  const actionCreator = createPutRequest(REQUEST_TYPE, {})
+  const action = actionCreator()
+  expect(action[LP_API].method).toEqual('PUT')
+})
+
+test('createPatchRequest creates a request with method PATCH', () => {
+  const actionCreator = createPatchRequest(REQUEST_TYPE, {})
+  const action = actionCreator()
+  expect(action[LP_API].method).toEqual('PATCH')
+})
+
+test('createDeleteRequest creates a request with method DELETE', () => {
+  const actionCreator = createDeleteRequest(REQUEST_TYPE, {})
+  const action = actionCreator()
+  expect(action[LP_API].method).toEqual('DELETE')
+})