fetchbasequery 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 h41ku
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# fetchBaseQuery
+
+Library for easily make HTTP queries without mass of boilerplate code.
+
+Usage
+-----
+
+Build base query function:
+
+```js
+import fetchBaseQuery, { baseQuery, encodeBody, accessToken, jsonReply, commonReply } from 'fetchbasequery'
+
+const query = fetchBaseQuery({
+    baseUrl: 'https://api.example.org/v1'
+    baseQuery,
+    logErrors: true,
+    middleware: [
+        encodeBody(),
+        accessToken({
+            getAccessToken: () => localStorage.getItem('access_token'),
+            setAccessToken: (token) => localStorage.setItem('access_token', token),
+            getUpdatedAccessToken: (response) => response.headers.get('X-Access-Token')
+        }),
+        jsonReply(),
+        commonReply()
+    ]
+})
+```
+
+Now get easy to make queries:
+
+```js
+const response = await query({ url: '/users/me' }) // don't worry about catching errors
+const { status, success, error } = response
+if (success) {
+    setUser(response.data)
+} else if (error) {
+    setError(response.message)
+} else {
+    setError(`Unexpected status code: ${status}`)
+}
+```
+
+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).

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "fetchbasequery",
+  "version": "0.0.1",
+  "description": "Library for easily make HTTP queries without mass of boilerplate code.",
+  "type": "module",
+  "main": "src/fetchBaseQuery.js",
+  "types": "types/index.d.ts",
+  "scripts": {
+  },
+  "keywords": [
+  ],
+  "author": "h41ku <h41ku.c0de@ya.ru>",
+  "license": "MIT",
+  "dependencies": {
+  },
+  "devDependencies": {
+  }
+}

package/src/baseQuery.js

@@ -0,0 +1,58 @@
+import responseFromError from './helpers/responseFromError.js'
+import purge from './helpers/purge.js'
+
+export default async ({ url: endpoint, ...options } = {}) => {
+    const {
+        baseUrl,
+        logErrors,
+        ...restOptions
+    } = {
+        logErrors: false,
+        baseUrl: globalThis.location
+            ? globalThis.location.origin
+            : 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
+    // combine extracted options and remove undefined properties
+    const fetchOptions = purge({ method, headers, body, mode, credentials, cache, redirect,
+        referrer, referrerPolicy, integrity, keepalive, signal })
+    // do request
+    let response
+    try {
+        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
+            )
+        }
+        response = await fetch(url, {
+            ...defaultFetchOptions,
+            ...fetchOptions
+        })
+    } catch (error) {
+        if (logErrors) {
+            console.error('fetchBaseQuery/query', error)
+        }
+        return responseFromError(error)
+    }
+    return response
+}

package/src/fetchBaseQuery.js

@@ -0,0 +1,14 @@
+// const pipeAsync = (...fns) => (input) => fns.reduce((chain, func) => chain.then(func), Promise.resolve(input))
+import pipe from './helpers/pipe.js'
+import defaultBaseQuery from './baseQuery.js'
+
+export default ({ baseQuery, middlewares, ...defaultOptions } = {}) => {
+    const pipedQuery = pipe(...(middlewares || []))(baseQuery || defaultBaseQuery)
+    return options => pipedQuery({
+        ...defaultOptions,
+        ...options
+    })
+}
+
+export { defaultBaseQuery as baseQuery }
+export * from './middlewares/index.js'

package/src/helpers/encodeJson.js

@@ -0,0 +1,8 @@
+export default body => JSON.stringify(body, (key, value) => {
+    if (value instanceof Error) {
+        return value.stack.split(/\r?\n/g)
+    } else if (typeof value === 'bigint') {
+        return value.toString()
+    }
+    return value
+})

package/src/helpers/pipe.js

@@ -0,0 +1 @@
+export default (...fns) => (input) => fns.reduce((chain, f) => f(chain), input)

package/src/helpers/purge.js

@@ -0,0 +1,4 @@
+export default object => Object.fromEntries(
+    Object.entries(object)
+        .filter(entry => entry[1] !== undefined)
+)

package/src/helpers/responseFromError.js

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

package/src/middlewares/accessToken.js

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

package/src/middlewares/commonReply.js

@@ -0,0 +1,14 @@
+export default () => query => async (options) => {
+    const { status, data, error, headers } = await query(options)
+    if (error) {
+        return { status, error: true, message: error.message, headers }
+    } else if (data) {
+        if (data.success) {
+            return { ...data, status, headers }
+        } else if (data.error) {
+            return { status, error: true, message: data.message, headers }
+        }
+        return { status, error: true, message: 'Unexpected format of common response body.', headers }
+    }
+    return { status, headers }
+}

package/src/middlewares/encodeBody.js

@@ -0,0 +1,78 @@
+import purge from '../helpers/purge.js'
+import encodeJson from '../helpers/encodeJson.js'
+import responseFromError from '../helpers/responseFromError.js'
+
+const getEncodedBody = body => (
+    typeof blob === 'string'
+    || body instanceof String
+    || body instanceof FormData
+    || body instanceof Blob
+    || body instanceof ArrayBuffer
+    || body instanceof DataView
+    || body instanceof File
+    || body instanceof ReadableStream
+    || body instanceof Int8Array
+    || body instanceof Uint8Array
+    || body instanceof Int16Array
+    || body instanceof Uint16Array
+    || body instanceof Int32Array
+    || body instanceof Uint32Array
+    || body instanceof BigInt64Array
+    || body instanceof BigUint64Array
+        ? body // raw
+        : (
+            body instanceof URLSearchParams
+                ? body.toString()
+                : encodeJson(body) // default
+          )
+)
+
+const detectContentType = ({ body }) => {
+    if (body instanceof ArrayBuffer
+        || body instanceof DataView
+        || body instanceof ReadableStream
+        || body instanceof Int8Array
+        || body instanceof Uint8Array
+        || body instanceof Int16Array
+        || body instanceof Uint16Array
+        || body instanceof Int32Array
+        || body instanceof Uint32Array
+        || body instanceof BigInt64Array
+        || body instanceof BigUint64Array
+    ) return 'application/octet-stream'
+    if (body instanceof URLSearchParams) return 'application/x-www-form-urlencoded'
+    if (body instanceof FormData) return 'multipart/form-data'
+    if (body instanceof Object) return 'application/json; charset=utf-8'
+    // return undefined
+}
+
+export default (settings = {}) => (query) => async ({ body, headers, ...options } = {}) => {
+    const {
+        contentType,
+        encodeBody
+    } = {
+        contentType: detectContentType,
+        encodeBody: getEncodedBody,
+        ...settings
+    }
+    let response
+    let status = 0
+    try {
+        response = await query({
+            ...options,
+            headers: purge({
+                'Content-Type': contentType instanceof Function
+                    ? contentType({ body })
+                    : contentType,
+                ...(headers || {})
+            }),
+            body: encodeBody(body)
+        })
+    } catch (error) {
+        if (options.logErrors) {
+            console.error('fetchBaseQuery/middlewares/accessToken', error)
+        }
+        return responseFromError(error, status)
+    }
+    return response
+}

package/src/middlewares/index.js

@@ -0,0 +1,4 @@
+export { default as accessToken } from './accessToken.js'
+export { default as encodeBody } from './encodeBody.js'
+export { default as commonReply } from './commonReply.js'
+export { default as jsonReply } from './jsonReply.js'

package/src/middlewares/jsonReply.js

@@ -0,0 +1,25 @@
+export default (settings = {}) => query => async (options = {}) => {
+    const {
+        isJsonBody
+    } = {
+        isJsonBody: (response) => /^application\/json/i.test(response.headers.get('Content-Type')),
+        ...settings
+    }
+    const response = await query(options)
+    const { status, error, headers } = response
+    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)
+        }
+        return { status, error, headers }
+    }
+    return { status, data, headers }
+}

package/types/index.d.ts

@@ -0,0 +1,41 @@
+export type fetchInit = {
+    logErrors: boolean | undefined,
+    method: string | undefined,
+    headers: object | undefined,
+    body: string
+        | object
+        | FormData
+        | Blob
+        | ArrayBuffer
+        | DataView
+        | File
+        | ReadableStream
+        | Int8Array
+        | Uint8Array
+        | Int16Array
+        | Uint16Array
+        | Int32Array
+        | Uint32Array
+        | BigInt64Array
+        | BigUint64Array
+        | URLSearchParams
+        | undefined,
+    mode: string | undefined,
+    credentials: string | undefined,
+    cache: string | undefined,
+    redirect: string | undefined,
+    referrer: string | undefined,
+    referrerPolicy: string | undefined,
+    integrity: string | undefined,
+    keepalive: boolean | undefined,
+    signal: AbortSignal | undefined
+};
+
+export type queryFn = (options: fetchInit | any | undefined) => Promise<any>;
+export type Middleware = (settings: any) => (query: queryFn) => queryFn;
+
+export type fetchBaseQueryInit = {
+    baseUrl: URL | string  | undefined,
+    baseQuery: queryFn,
+    middlewares: Array<Middleware>
+};