@beyonk/http 12.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,60 @@
+name: publish
+
+on:
+  push:
+    branches:
+      - '*'
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: master
+
+      - uses: volta-cli/action@v4
+
+      - name: Cache pnpm modules
+        uses: actions/cache@v2
+        with:
+          path: ~/.pnpm-store
+          key: ${{ runner.os }}-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-
+
+      - uses: pnpm/action-setup@v2.2.4
+        with:
+          run_install: true
+
+      - run: pnpm lint
+
+  publish-npm:
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: master
+
+      - uses: volta-cli/action@v4
+
+      - name: Authorize NPM
+        run: npm config set //registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}
+
+      - name: Cache pnpm modules
+        uses: actions/cache@v2
+        with:
+          path: ~/.pnpm-store
+          key: ${{ runner.os }}-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-
+
+      - uses: pnpm/action-setup@v2.2.4
+        with:
+          run_install: true
+
+      - run: pnpm publish

package/README.MD

@@ -0,0 +1,301 @@
+<a href="https://beyonk.com">
+  <img src="https://user-images.githubusercontent.com/218949/144224348-1b3a20d5-d68e-4a7a-b6ac-6946f19f4a86.png" width="198" />
+</a>
+
+## Http
+
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com) ![publish](https://github.com/beyonk-adventures/http/workflows/publish/badge.svg?branch=master)
+
+Isomorphic fetch library.
+<br />
+Formerly known as `@beyonk/sapper-httpclient`
+
+## Why
+
+In hybrid applications, there are three different ways of fetching data:
+
+* client
+* server
+* isomorphic (client + server)
+* retries (on various network errors)
+
+This library helps you abstract over where you are fetching data, meaning that your code maintains consistency without having to worry about where your data is being fetched.
+
+The way it does this is by trying to use the first available fetch method, and failing over to alternatives if a  method is not available. The methods it tries are, in the following order:
+
+1. Any fetch library you pass to `create()` (for example, `load`'s `fetch`)
+1. window.fetch if the library detects it is running clientside
+1. `node-fetch`, or whatever you want to pass in, if nothing else is available (pure server-side)
+
+Generally this means that your usage is the same no matter where you call it, with one exception - using this library in the `load` method requires you to pass in SvelteKit's special `fetch` method, as it is not available outside of the load method. Examples of which are below.
+
+## Usage
+
+### To use within an application:
+
+### Install it
+
+```bash
+npm i -D @beyonk/http
+```
+
+### Configure it (both server-side and client-side as there are two bundles)
+
+```js
+// src/client.js && src/server.js
+import Api from '@beyonk/http'
+
+Api.configure({ baseUrl: 'https://example.com/your/api/base' })
+```
+
+### Use it on the client:
+
+```js
+// src/routes/some-route.html
+import { create } from '@beyonk/http'
+
+// in a method (client-side)
+const api = create()
+const json = await api.endpoint('some/endpoint').get()
+console.log(json)
+
+// in load (isomorphic)
+const api = create()
+const json = await api
+  .context({ fetch }) // Pass in the "fetch" parameter from load
+  .endpoint('some/endpoint')
+  .get()
+console.log(json)
+```
+
+### Use it on the server:
+
+```js
+// src/routes/+page.server.js
+import fetch from 'node-fetch' // or SvelteKit's built in fetch
+import { create } from '@beyonk/http'
+
+const api = create()
+const json = await api
+  .context({ fetch }) // pass node fetch in here.
+  .endpoint('some/endpoint')
+  .get()
+console.log(json)
+```
+
+### Handling the response
+
+```js
+import { create } from '@beyonk/http'
+
+const api = create()
+const json = await api
+  .endpoint('some/endpoint')
+  .get((json, httpStatus) => {
+    console.log('json response is', json)
+    console.log('http status code is', httpStatus)
+  })
+```
+
+## Methods
+
+```js
+const api = create()
+const client = api
+  .endpoint('some/endpoint')
+
+console.log(await client.get()) // Get endpoint
+console.log(await client.payload({ foo: 'bar' }).put()) // Put with body
+console.log(await client.payload({ foo: 'bar' }).post()) // Post with body
+console.log(await client.query({ foo: 'bar' }).get()) // Get with query
+console.log(await client.del()) // Delete
+console.log(await client.headers({ foo: 'bar' }).put()) // Put with headers
+```
+
+#### client.query
+
+The `query` method accepts an object of params as either a String or Array of Strings.
+If any property passed into the query is `undefined` it will be ignored. 
+
+```js
+const api = create()
+const client = api
+  .endpoint('some/endpoint')
+
+console.log(await client.query({ foo: 'bar' }).get()) // will make a GET request to 'some/endpoint?foo=bar'
+console.log(await client.query({ foo: 'bar', baz: 'qux' }).get()) // will make a GET request to 'some/endpoint?foo=bar&baz=qux
+console.log(await client.query({ foo: ['bar', 'qux' ] }).get()) // will make a GET request to 'some/endpoint?foo=bar&foo=qux
+console.log(await client.query({ foo: undefined, baz: 'qux' }).get()) // will make a GET request to 'some/endpoint?baz=qux
+
+```
+
+## Using built in response handling
+
+```js
+const api = create()
+const profile = await api
+  .endpoint('some/endpoint')
+  .get(json => {
+    return json.profile
+  })
+console.log(profile)
+```
+
+## Catching errors
+
+### Per request
+
+If no local error handler is specified, the fallback handler `default` is called. If this isn't specified, the error is logged to the console.
+
+```js
+  await client
+    .endpoint('some/url')
+    .forbidden(e => {
+      console.error('Forbidden', e)
+    })
+    .gone(e => {
+      console.error('Gone', e)
+    })
+    .notFound(e => {
+      console.error('Not found', e)
+    })
+    .accessDenied(e => {
+      console.error('Access denied', e)
+    })
+    .conflict(e => {
+      console.error('Conflict', e)
+    })
+    .paymentRequired(e => {
+      console.error('Payment Required', e)
+    })
+    .preconditionFailed(e => {
+      console.error('Precondition failed', e)
+    })
+    .badData(e => {
+      console.error('Bad data', e)
+    })
+    .default(e => {
+      // Any other error caught here
+      console.error('Some error', e)
+    })
+    .get()
+```
+
+#### Handler signature
+
+Handlers have a signature with two items:
+
+```js
+.badData((e, ctx) => {
+  console.error('Bad data', e)
+  ctx.redirect('/foo/bar')
+  // or
+  ctx.error('/foo/bar')
+})
+```
+
+ctx can be whatever you want really - it is whatever you pass in as `context(...)`.
+
+However, if the `context` object you pass in has a `fetch` function, this is used as the `fetch` for XHR requests.
+
+```js
+export async function preload () {
+  await Api
+    .context(this) // fetch, redirect, error.
+    .endpoint('foo/bar')
+    ...
+}
+```
+
+you can also pass in other things to the context:
+
+```js
+export async function preload () {
+  await Api
+    .context({ ...this, baz: 'qux' })
+    .endpoint('foo/bar')
+    ...
+}
+```
+
+### At a global level
+
+Request local error handlers override global error handlers, but if a local error handler are not specified, these will be called instead, if it exists.
+
+Names are the same as the local handlers:
+
+```js
+  import Api from '@beyonk/http'
+  import { redirect } from '@sveltejs/kit'
+
+  Api.configure({
+    baseUrl: 'https://example.com/your/api/base',
+    handlers: {
+      paymentRequired(e => {
+        redirect(307, '/checkout')
+      })
+    }
+  })
+
+  await client
+    .endpoint('some/url')
+    .get()
+```
+
+## Retries
+
+The http client can retry if a network error is encountered. The default is `retry: false`, and requests won't be retried.
+
+Configure it as follows:
+
+```js
+import Api from '@beyonk/http'
+
+Api.configure({
+  retry: {
+    attempts: 3 // How many times to retry before giving up
+    errors: [ 'ECONNRESET' ] // A list of error codes
+  }
+})
+```
+
+errors is an array of any number of the [nodejs network error codes](https://nodejs.org/api/errors.html#errors_common_system_errors)
+
+
+## Parsing error payloads
+
+As of v7.0.0 the library defaults to parsing error payloads as JSON. This means you can use the data returned in your response.
+
+```js
+  /** endpoint returns 401 with:
+    {
+      username: 'Naughty User'
+    }
+  **/
+
+  await client
+    .endpoint('some/url')
+    .accessDenied(e => {
+      console.error('You are not allowed', e.body.username)
+    })
+```
+
+To turn this behaviour off, pass the option `parseErrors` with value false:
+
+```js
+import Api from '@beyonk/http'
+
+Api.configure({
+  parseErrors: false
+})
+```
+
+## Running Tests
+
+```sh
+npm test
+```
+
+## Credits
+
+* Original code by [Antony Jones](https://github.com/antony)

package/lib/api/_just-compose.js

@@ -0,0 +1,12 @@
+function compose (...fns) {
+  return function () {
+    var result = fns[0].apply(this, arguments)
+    var len = fns.length
+    for (var i = 1; i < len; i++) {
+      result = fns[i].call(this, result)
+    }
+    return result
+  }
+}
+
+export { compose }

package/lib/api/index.js

@@ -0,0 +1,231 @@
+import { AccessDeniedMixin } from '../error-handlers/access-denied.js'
+import { ConflictMixin } from '../error-handlers/conflict.js'
+import { DefaultMixin } from '../error-handlers/default.js'
+import { ForbiddenMixin } from '../error-handlers/forbidden.js'
+import { HandleMixin } from '../error-handlers/handle.js'
+import { NotFoundMixin } from '../error-handlers/not-found.js'
+import { BadDataMixin } from '../error-handlers/bad-data.js'
+import { PaymentRequiredMixin } from '../error-handlers/payment-required.js'
+import { PreconditionFailedMixin } from '../error-handlers/precondition-failed.js'
+import { TooManyRequestsMixin } from '../error-handlers/too-many-requests.js'
+import { NotAcceptableMixin } from '../error-handlers/not-acceptable.js'
+import { GoneMixin } from '../error-handlers/gone.js'
+import { byCode } from '../errors.js'
+import { compose } from './_just-compose.js'
+
+class ApiBase {}
+const Behaviours = compose(
+  AccessDeniedMixin,
+  ConflictMixin,
+  DefaultMixin,
+  ForbiddenMixin,
+  HandleMixin,
+  NotFoundMixin,
+  BadDataMixin,
+  PaymentRequiredMixin,
+  PreconditionFailedMixin,
+  TooManyRequestsMixin,
+  NotAcceptableMixin,
+  GoneMixin
+)(ApiBase)
+
+class Api extends Behaviours {
+  constructor (options) {
+    super()
+    this.options = Object.assign({
+      retry: false,
+      parseErrors: true,
+      handlers: {}
+    }, options)
+
+    this.handlers = {}
+    this.client = null
+    this.resetRequest()
+  }
+
+  resetRequest () {
+    this.config = {
+      endpoint: null,
+      method: 'get',
+      payload: null,
+      query: null,
+      headers: {},
+      overrides: {}
+    }
+  }
+
+  getClient () {
+    if (this.options.mock) {
+      console.warn('@beyonk/http: Using mocked http client')
+      return this.options.mock
+    }
+
+    if (this.client) {
+      return this.client
+    } else if (typeof window !== 'undefined') {
+      return window.fetch.bind(window)
+    }
+
+    throw Error("No client provided and can't find one automatically")
+  }
+
+  async send (fn) {
+    const endpoint = this.config.endpoint.includes('://') ? this.config.endpoint : `${this.options.baseUrl}/${this.config.endpoint}`
+    const hasPayload = !!this.config.payload
+
+    const options = Object.assign(
+      {
+        method: this.config.method,
+        cors: true,
+        credentials: 'include',
+        headers: Object.assign(
+          { Accept: 'application/json' },
+          hasPayload ? { 'Content-Type': 'application/json' } : {},
+          this.config.headers
+        )
+      },
+      hasPayload ? { body: JSON.stringify(this.config.payload) } : {},
+      this.config.overrides
+    )
+
+    const client = this.getClient()
+    const ep = this.config.query ? `${endpoint}?${this.config.query}` : `${endpoint}`
+
+    let result
+    try {
+      result = await this._doQuery(1, client, ep, options)
+    } catch (e) {
+      console.log(e)
+      return this.handle(e, this.ctx)
+    } finally {
+      this.resetRequest()
+    }
+
+    const { json, httpStatus } = result
+    return fn ? fn(json, httpStatus) : json
+  }
+
+  _hasContent (response) {
+    const contentLength = parseInt(response.headers.get('content-length'), 10)
+
+    const isNoContentResponse = response.status === 204
+    if (isNoContentResponse) {
+      return false
+    }
+
+    const headerExists = !isNaN(contentLength)
+    return !headerExists || contentLength > 0
+  }
+
+  async _doQuery (attempt, client, endpoint, options) {
+    const retry = this.options.retry || { attempts: 1 }
+    try {
+      const r = await client(endpoint, options)
+
+      if (r.status >= 200 && r.status < 400) {
+        let json
+
+        if (this._hasContent(r)) {
+          try {
+            json = await r.json()
+          } catch (e) {
+            console.error('Unable to parse response json', e.message)
+          }
+        }
+
+        return { httpStatus: r.status, json }
+      }
+
+      let content = ''
+      try {
+        content = this.options.parseErrors ? await r.json() : await r.text()
+      } catch (e) {
+        console.log('Failed to parse error body when asked.')
+      }
+
+      const ClientError = byCode(r.status)
+      throw new ClientError(r.statusText, content)
+    } catch (e) {
+      if (attempt < retry.attempts && retry.errors.includes(e.code)) {
+        console.warn(`Got ${e.code} when calling ${endpoint}. Retrying request (${attempt}/${retry.attempts})`)
+        return this._doQuery(++attempt, client, endpoint, options)
+      }
+
+      throw e
+    }
+  }
+
+  context (ctx) {
+    if (ctx.fetch) {
+      this.client = ctx.fetch
+    }
+    this.ctx = ctx
+    return this
+  }
+
+  override (override) {
+    this.config.overrides = override
+    return this
+  }
+
+  headers (headers) {
+    this.config.headers = headers
+    return this
+  }
+
+  async get (fn) {
+    this.config.method = 'GET'
+    return this.send(fn)
+  }
+
+  async post (fn) {
+    this.config.method = 'POST'
+    return this.send(fn)
+  }
+
+  async patch (fn) {
+    this.config.method = 'PATCH'
+    return this.send(fn)
+  }
+
+  async put (fn) {
+    this.config.method = 'PUT'
+    return this.send(fn)
+  }
+
+  async del (fn) {
+    this.config.method = 'DELETE'
+    return this.send(fn)
+  }
+
+  endpoint (endpoint) {
+    this.config.endpoint = endpoint
+    return this
+  }
+
+  query (query) {
+    const q = Object.entries(query).reduce((curr, [ k, v ]) => {
+      if (typeof v === 'undefined') {
+        return curr
+      }
+      if (Array.isArray(v)) {
+        curr.push(...v.map(n => `${k}=${encodeURIComponent(n)}`))
+      } else {
+        curr.push(`${k}=${encodeURIComponent(v)}`)
+      }
+      return curr
+    }, [])
+
+    this.config.query = q.join('&')
+    return this
+  }
+
+  payload (payload) {
+    this.config.payload = payload
+    return this
+  }
+}
+
+export {
+  Api
+}