fetchbasequery 0.0.1 → 0.1.0

package/README.md

@@ -2,8 +2,21 @@
 
 Library for easily make HTTP queries without mass of boilerplate code.
 
-Usage
------
+## Installation
+
+NPM:
+
+```sh
+npm install fetchbasequery
+```
+
+PNPM:
+
+```sh
+pnpm add fetchbasequery
+```
+
+## Usage
 
 Build base query function:
 
@@ -11,15 +24,22 @@ Build base query function:
 import fetchBaseQuery, { baseQuery, encodeBody, accessToken, jsonReply, commonReply } from 'fetchbasequery'
 
 const query = fetchBaseQuery({
+    // main options ...
     baseUrl: 'https://api.example.org/v1'
     baseQuery,
     logErrors: true,
+    // add some defaults for `fetch()` ...
+    mode: 'cors',
+    credentials: 'include',
+    cache: 'reload',
+    // middlewares
     middleware: [
         encodeBody(),
         accessToken({
             getAccessToken: () => localStorage.getItem('access_token'),
             setAccessToken: (token) => localStorage.setItem('access_token', token),
-            getUpdatedAccessToken: (response) => response.headers.get('X-Access-Token')
+            removeAccessToken: (token) => localStorage.removeItem('access_token'),
+            getUpdatedAccessToken: async (response) => response.headers.get('X-Access-Token')
         }),
         jsonReply(),
         commonReply()
@@ -41,6 +61,20 @@ if (success) {
 }
 ```
 
+Using instance of `Request`:
+
+```js
+// for example inside ServiceWorker
+addEventListener('fetch', evt => {
+    const { request } = evt
+    return evt.respondWith(query({ request }))
+})
+```
+
 It works fine both on frontend and backend sides. For backend side usage Node.js v18+ is required,
 because the middleware `baseQuery` based on `Fetch API`. But it can be replaced with your own
 implementation based on another API (e.g. based on `axios` etc).
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fetchbasequery",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Library for easily make HTTP queries without mass of boilerplate code.",
   "type": "module",
   "main": "src/fetchBaseQuery.js",
@@ -8,6 +8,7 @@
   "scripts": {
   },
   "keywords": [
+    "fetch", "fetchBaseQuery"
   ],
   "author": "h41ku <h41ku.c0de@ya.ru>",
   "license": "MIT",

package/src/baseQuery.js

@@ -1,10 +1,13 @@
 import responseFromError from './helpers/responseFromError.js'
 import purge from './helpers/purge.js'
 
-export default async ({ url: endpoint, ...options } = {}) => {
+const moduleName = 'fetchBaseQuery/baseQuery'
+
+export default async ({ url: endpoint, request: subject, ...options } = {}) => {
     const {
         baseUrl,
         logErrors,
+        debug,
         ...restOptions
     } = {
         logErrors: false,
@@ -13,12 +16,6 @@ export default async ({ url: endpoint, ...options } = {}) => {
             : undefined,
         ...options
     }
-    // default options for `fetch()`
-    const defaultFetchOptions = {
-        method: 'GET',
-        cache: 'reload',
-        credentials: 'include',
-    }
     // extract options which are known by `fetch()`
     const { method, headers, body, mode, credentials, cache, redirect,
         referrer, referrerPolicy, integrity, keepalive, signal } = restOptions
@@ -26,33 +23,41 @@ export default async ({ url: endpoint, ...options } = {}) => {
     const fetchOptions = purge({ method, headers, body, mode, credentials, cache, redirect,
         referrer, referrerPolicy, integrity, keepalive, signal })
     // do request
+    let request
     let response
     try {
-        let url, origin, prefix = '/'
-        if (baseUrl) {
-            const url = new URL(baseUrl)
-            origin = url.origin
-            prefix = url.pathname
+        if (endpoint !== undefined) {
+            let url, origin, prefix = '/'
+            if (baseUrl) {
+                const url = new URL(baseUrl)
+                origin = url.origin
+                prefix = url.pathname
+            }
+            try {
+                url = new URL(endpoint)
+            } catch (error) {
+                url = new URL(
+                    /\/$/.test(prefix) && /^\//.test(endpoint)
+                        ? prefix + endpoint.substring(1)
+                        : prefix + endpoint,
+                    origin
+                )
+            }
+            subject = url
         }
-        try {
-            url = new URL(endpoint)
-        } catch (error) {
-            url = new URL(
-                /\/$/.test(prefix) && /^\//.test(endpoint)
-                    ? prefix + endpoint.substring(1)
-                    : prefix + endpoint,
-                origin
-            )
+        request = new Request(subject, fetchOptions)
+        if (debug?.baseQuery) {
+            console.log(moduleName, { request })
         }
-        response = await fetch(url, {
-            ...defaultFetchOptions,
-            ...fetchOptions
-        })
+        response = await fetch(request)
     } catch (error) {
         if (logErrors) {
-            console.error('fetchBaseQuery/query', error)
+            console.error(moduleName, error)
         }
-        return responseFromError(error)
+        response = responseFromError(error)
+    }
+    if (debug?.baseQuery) {
+        console.log(moduleName, { response })
     }
     return response
 }

package/src/helpers/responseFromError.js

@@ -1,7 +1,5 @@
-export default (error, status = 0) => ({
-    status,
-    error: typeof error === 'string'
-        ? { message: error }
-        : error,
-    headers: new Headers()
-})
+export default (error) => {
+    const response = Response.error()
+    response.error = error
+    return response
+}

package/src/middlewares/accessToken.js

@@ -1,44 +1,61 @@
 import responseFromError from '../helpers/responseFromError.js'
 import purge from '../helpers/purge.js'
 
+const moduleName = 'fetchBaseQuery/middlewares/accessToken'
+
 export default (settings = {}) => query => async ({ payload, headers, ...options } = {}) => {
     const {
         getAccessToken,
         setAccessToken,
+        removeAccessToken,
         isUnauthorized,
-        getUpdatedAccessToken
+        getUpdatedAccessToken,
+        getAuthorizationHeaders
     } = {
         getAccessToken: (payload) => undefined,
         setAccessToken: (token) => {},
+        removeAccessToken: () => {},
         isUnauthorized: (response) => response.status === 401,
-        getUpdatedAccessToken: (response) => undefined,
+        getUpdatedAccessToken: async (response) => undefined,
+        getAuthorizationHeaders: (accessToken) => (
+            accessToken
+                ? { Authorization: `bearer ${accessToken}` }
+                : {}
+        ),
         ...settings
     }
     let response
-    let status = 0
     try {
-        const accessToken = getAccessToken(payload)
         response = await query({
             ...options,
             headers: purge({
-                ...(accessToken ? { Authorization: `bearer ${accessToken}` } : {}),
+                ...(getAuthorizationHeaders(getAccessToken(payload))),
                 ...(headers || {})
             })
         })
-        status = response.status
+    } catch (error) {
+        if (options.logErrors) {
+            console.error(moduleName, error)
+        }
+        response = responseFromError(error)
+    }
+    try {
         if (isUnauthorized(response)) {
-            setAccessToken(null) // special case to remove access token from storage
+            removeAccessToken()
         } else {
-            const updatedAccessToken = getUpdatedAccessToken(response)
+            const updatedAccessToken = await getUpdatedAccessToken(response)
             if (updatedAccessToken) {
                 setAccessToken(updatedAccessToken)
             }
         }
     } catch (error) {
         if (options.logErrors) {
-            console.error('fetchBaseQuery/middlewares/accessToken', error)
+            console.error(moduleName, error)
         }
-        return responseFromError(error, status)
+        response = responseFromError(error)
+    }
+    if (options.debug?.accessToken) {
+        console.log(moduleName, { response })
     }
     return response
 }

package/src/middlewares/commonReply.js

@@ -1,14 +1,23 @@
+const moduleName = 'fetchBaseQuery/middlewares/commonReply'
+
 export default () => query => async (options) => {
     const { status, data, error, headers } = await query(options)
+    let reply
     if (error) {
-        return { status, error: true, message: error.message, headers }
+        reply = { status, error: true, message: error.message || error, headers }
     } else if (data) {
         if (data.success) {
-            return { ...data, status, headers }
+            reply = { ...data, status, headers }
         } else if (data.error) {
-            return { status, error: true, message: data.message, headers }
+            reply = { status, error: true, message: data.message, headers }
+        } else {
+            reply = { status, error: true, message: 'Unexpected format of common response body.', headers }
         }
-        return { status, error: true, message: 'Unexpected format of common response body.', headers }
+    } else {
+        reply = { status, headers }
     }
-    return { status, headers }
+    if (options.debug?.commonReply) {
+        console.log(moduleName, { reply })
+    }
+    return reply
 }

package/src/middlewares/encodeBody.js

@@ -2,6 +2,8 @@ import purge from '../helpers/purge.js'
 import encodeJson from '../helpers/encodeJson.js'
 import responseFromError from '../helpers/responseFromError.js'
 
+const moduleName = 'fetchBaseQuery/middlewares/accessToken'
+
 const getEncodedBody = body => (
     typeof blob === 'string'
     || body instanceof String
@@ -56,7 +58,6 @@ export default (settings = {}) => (query) => async ({ body, headers, ...options
         ...settings
     }
     let response
-    let status = 0
     try {
         response = await query({
             ...options,
@@ -70,9 +71,12 @@ export default (settings = {}) => (query) => async ({ body, headers, ...options
         })
     } catch (error) {
         if (options.logErrors) {
-            console.error('fetchBaseQuery/middlewares/accessToken', error)
+            console.error(moduleName, error)
         }
-        return responseFromError(error, status)
+        response = responseFromError(error)
+    }
+    if (options.debug?.encodeBody) {
+        console.log(moduleName, { response })
     }
     return response
 }

package/src/middlewares/jsonReply.js

@@ -1,3 +1,5 @@
+const moduleName = 'fetchBaseQuery/middlewares/jsonReply'
+
 export default (settings = {}) => query => async (options = {}) => {
     const {
         isJsonBody
@@ -7,19 +9,27 @@ export default (settings = {}) => query => async (options = {}) => {
     }
     const response = await query(options)
     const { status, error, headers } = response
+    let reply
     if (error) {
-        return { status, error, headers }
-    }
-    let data
-    try {
-        if (isJsonBody(response) && response.json) {
-            data = await response.json()
-        }
-    } catch (error) {
-        if (options.logErrors) {
-            console.error('fetchBaseQuery/middlewares/jsonReply', error)
+        reply = { status, error, headers }
+    } else {
+        let data
+        try {
+            if (isJsonBody(response)) {
+                data = await response.json()
+                reply = { status, data, headers }
+            } else {
+                reply = { status, headers }
+            }
+        } catch (error) {
+            if (options.logErrors) {
+                console.error(moduleName, error)
+            }
+            reply = { status, error, headers }
         }
-        return { status, error, headers }
     }
-    return { status, data, headers }
+    if (options.debug?.jsonReply) {
+        console.log(moduleName, { reply })
+    }
+    return reply
 }

package/types/index.d.ts

@@ -1,5 +1,15 @@
-export type fetchInit = {
+export type DebuggingFlags = {
+    baseQuery: boolean | undefined,
+    encodeBody: boolean | undefined,
+    accessToken: boolean | undefined,
+    jsonReply: boolean | undefined,
+    commonReply: boolean | undefined
+};
+
+export type FetchOptions = {
     logErrors: boolean | undefined,
+    url: URL | string | undefined,
+    request: Request | undefined,
     method: string | undefined,
     headers: object | undefined,
     body: string
@@ -28,14 +38,27 @@ export type fetchInit = {
     referrerPolicy: string | undefined,
     integrity: string | undefined,
     keepalive: boolean | undefined,
-    signal: AbortSignal | undefined
+    signal: AbortSignal | undefined,
+    debug: DebuggingFlags | undefined
 };
 
-export type queryFn = (options: fetchInit | any | undefined) => Promise<any>;
-export type Middleware = (settings: any) => (query: queryFn) => queryFn;
+export type baseQueryFn = (options: FetchOptions | undefined) => Promise<Response>;
+export type queryFn = (options: FetchOptions | undefined) => Promise<any>;
+export type middlewareFn = (settings: any) => (query: queryFn) => queryFn;
 
-export type fetchBaseQueryInit = {
+export type FetchBaseQueryOptions = {
     baseUrl: URL | string  | undefined,
-    baseQuery: queryFn,
-    middlewares: Array<Middleware>
+    baseQuery: baseQueryFn | undefined,
+    middlewares: Array<middlewareFn>
 };
+
+export const baseQuery: baseQueryFn;
+
+export const encodeBody: middlewareFn;
+export const accessToken: middlewareFn;
+export const jsonReply: middlewareFn;
+export const commonReply: middlewareFn;
+
+const fetchBaseQuery: (options: FetchBaseQueryOptions & FetchOptions) => queryFn;
+
+export default fetchBaseQuery;