@beyonk/http 12.0.0

package/lib/entrypoint.js

@@ -0,0 +1,19 @@
+import { Api } from './api/index.js'
+import * as errors from './errors.js'
+
+let config
+
+function configure (options) {
+  config = options
+}
+
+function create () {
+  if (!config) { throw new Error('Api client must be configured') }
+  return new Api(config)
+}
+
+export default {
+  configure,
+  create,
+  errors
+}

package/lib/error-handlers/access-denied.js

@@ -0,0 +1,12 @@
+import {
+  AccessDeniedError
+} from '../errors.js'
+
+const AccessDeniedMixin = superclass => class AccessDenied extends superclass {
+  accessDenied (fn) {
+    this.handlers[AccessDeniedError.name] = fn
+    return this
+  }
+}
+
+export { AccessDeniedMixin }

package/lib/error-handlers/bad-data.js

@@ -0,0 +1,12 @@
+import {
+  BadDataError
+} from '../errors.js'
+
+const BadDataMixin = superclass => class BadData extends superclass {
+  badData (fn) {
+    this.handlers[BadDataError.name] = fn
+    return this
+  }
+}
+
+export { BadDataMixin }

package/lib/error-handlers/conflict.js

@@ -0,0 +1,12 @@
+import {
+  ConflictError
+} from '../errors.js'
+
+const ConflictMixin = superclass => class Conflict extends superclass {
+  conflict (fn) {
+    this.handlers[ConflictError.name] = fn
+    return this
+  }
+}
+
+export { ConflictMixin }

package/lib/error-handlers/default.js

@@ -0,0 +1,8 @@
+const DefaultMixin = superclass => class Default extends superclass {
+  default (fn) {
+    this.defaultHandler = fn
+    return this
+  }
+}
+
+export { DefaultMixin }

package/lib/error-handlers/expectation-failed.js

@@ -0,0 +1,12 @@
+import {
+  ExpectationFailedError
+} from '../errors.js'
+
+const ExpectationFailedMixin = superclass => class ExpectationFailed extends superclass {
+  expectationFailed (fn) {
+    this.handlers[ExpectationFailedError.name] = fn
+    return this
+  }
+}
+
+export { ExpectationFailedMixin }

package/lib/error-handlers/forbidden.js

@@ -0,0 +1,12 @@
+import {
+  ForbiddenError
+} from '../errors.js'
+
+const ForbiddenMixin = superclass => class Forbidden extends superclass {
+  forbidden (fn) {
+    this.handlers[ForbiddenError.name] = fn
+    return this
+  }
+}
+
+export { ForbiddenMixin }

package/lib/error-handlers/gone.js

@@ -0,0 +1,12 @@
+import {
+  GoneError
+} from '../errors.js'
+
+const GoneMixin = superclass => class Gone extends superclass {
+  gone (fn) {
+    this.handlers[GoneError.name] = fn
+    return this
+  }
+}
+
+export { GoneMixin }

package/lib/error-handlers/handle.js

@@ -0,0 +1,25 @@
+function getConstructorName (c) {
+  return Object.getPrototypeOf(c).constructor.name
+}
+
+function findHandlerInReallyUglyWay (localHandlers, globalHandlers, fallbackHandler, e) {
+  const constructorName = getConstructorName(e)
+  const globalHandlerName = `${constructorName[0].toLowerCase()}${constructorName.slice(1, -5)}`
+  return localHandlers[constructorName] ||
+    globalHandlers[globalHandlerName] ||
+    fallbackHandler
+}
+
+const HandleMixin = superclass => class Handle extends superclass {
+  get fallbackHandler () {
+    return this.defaultHandler || function (e) {
+      console.error(getConstructorName(e), e.message, e)
+    }
+  }
+
+  handle (e, ctx) {
+    return findHandlerInReallyUglyWay(this.handlers, this.options.handlers, this.fallbackHandler, e)(e, ctx)
+  }
+}
+
+export { HandleMixin }

package/lib/error-handlers/not-acceptable.js

@@ -0,0 +1,12 @@
+import {
+  NotAcceptableError
+} from '../errors.js'
+
+const NotAcceptableMixin = superclass => class NotAcceptable extends superclass {
+  notAcceptable (fn) {
+    this.handlers[NotAcceptableError.name] = fn
+    return this
+  }
+}
+
+export { NotAcceptableMixin }

package/lib/error-handlers/not-found.js

@@ -0,0 +1,12 @@
+import {
+  NotFoundError
+} from '../errors.js'
+
+const NotFoundMixin = superclass => class NotFound extends superclass {
+  notFound (fn) {
+    this.handlers[NotFoundError.name] = fn
+    return this
+  }
+}
+
+export { NotFoundMixin }

package/lib/error-handlers/payment-required.js

@@ -0,0 +1,12 @@
+import {
+  PaymentRequiredError
+} from '../errors.js'
+
+const PaymentRequiredMixin = superclass => class PaymentRequired extends superclass {
+  paymentRequired (fn) {
+    this.handlers[PaymentRequiredError.name] = fn
+    return this
+  }
+}
+
+export { PaymentRequiredMixin }

package/lib/error-handlers/precondition-failed.js

@@ -0,0 +1,12 @@
+import {
+  PreconditionFailedError
+} from '../errors.js'
+
+const PreconditionFailedMixin = superclass => class PreconditionFailed extends superclass {
+  preconditionFailed (fn) {
+    this.handlers[PreconditionFailedError.name] = fn
+    return this
+  }
+}
+
+export { PreconditionFailedMixin }

package/lib/error-handlers/too-many-requests.js

@@ -0,0 +1,12 @@
+import {
+  TooManyRequestsError
+} from '../errors.js'
+
+const TooManyRequestsMixin = superclass => class TooManyRequests extends superclass {
+  tooManyRequests (fn) {
+    this.handlers[TooManyRequestsError.name] = fn
+    return this
+  }
+}
+
+export { TooManyRequestsMixin }

package/lib/errors.js

@@ -0,0 +1,73 @@
+class HttpError extends Error {
+  constructor (message, body) {
+    super(message)
+    this.body = body
+  }
+}
+
+class AccessDeniedError extends HttpError {
+}
+
+class PaymentRequiredError extends HttpError {
+}
+
+class ForbiddenError extends HttpError {
+}
+
+class NotFoundError extends HttpError {
+}
+
+class ConflictError extends HttpError {
+}
+
+class ExpectationFailedError extends HttpError {
+}
+
+class PreconditionFailedError extends HttpError {
+}
+
+class BadDataError extends HttpError {
+}
+
+class NotAcceptableError extends HttpError {
+}
+
+class GoneError extends HttpError {
+}
+
+class TooManyRequestsError extends HttpError {
+}
+
+const mapping = {
+  401: AccessDeniedError,
+  402: PaymentRequiredError,
+  403: ForbiddenError,
+  404: NotFoundError,
+  406: NotAcceptableError,
+  409: ConflictError,
+  410: GoneError,
+  412: PreconditionFailedError,
+  417: ExpectationFailedError,
+  422: BadDataError,
+  429: TooManyRequestsError
+}
+
+function byCode (code) {
+  return mapping[code] || HttpError
+}
+
+export {
+  byCode,
+  AccessDeniedError,
+  PaymentRequiredError,
+  ForbiddenError,
+  NotFoundError,
+  NotAcceptableError,
+  HttpError,
+  GoneError,
+  ConflictError,
+  PreconditionFailedError,
+  ExpectationFailedError,
+  BadDataError,
+  TooManyRequestsError
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@beyonk/http",
+  "version": "12.0.0",
+  "description": "An isomorphic http client for Svelte apps",
+  "main": "lib/entrypoint.js",
+  "module": "lib/entrypoint.js",
+  "type": "module",
+  "directories": {
+    "lib": "lib"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/beyonk-adventures/http.git"
+  },
+  "devDependencies": {
+    "@beyonk/eslint-config": "^4.2.0",
+    "@beyonk/esm": "^4.0.1",
+    "@hapi/code": "^5.3.1",
+    "eslint": "^7.2.0",
+    "mocha": "^9.0.2",
+    "sinon": "^7.5.0"
+  },
+  "eslintConfig": {
+    "extends": "@beyonk",
+    "globals": {
+      "beforeEach": true,
+      "afterEach": true,
+      "describe": true,
+      "context": true,
+      "it": true
+    }
+  },
+  "keywords": [
+    "isomorphic",
+    "fetch",
+    "sapper",
+    "sveltekit",
+    "svelte",
+    "http-client",
+    "http",
+    "https"
+  ],
+  "author": "Antony Jones",
+  "license": "MIT",
+  "volta": {
+    "node": "18.15.0"
+  },
+  "packageManager": "pnpm@8.0.0",
+  "scripts": {
+    "test": "mocha './!(node_modules)/**/**.+(spec).js'",
+    "lint": "eslint lib --ext .js"
+  }
+}