@srfnstack/spliffy 0.9.2 → 0.9.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@srfnstack/spliffy",
-  "version": "0.9.2",
+  "version": "0.9.5",
   "author": "snowbldr",
   "private": false,
   "homepage": "https://github.com/narcolepticsnowman/spliffy",

package/src/errors.mjs

@@ -0,0 +1,254 @@
+export class HttpError extends Error {
+  constructor (statusCode, statusMessage, body) {
+    super()
+    this.statusCode = statusCode
+    this.statusMessage = statusMessage
+    this.body = body
+  }
+}
+
+export class BadRequestError extends HttpError {
+  constructor (body) {
+    super(400, 'Bad Request', body)
+  }
+}
+
+export class UnauthorizedError extends HttpError {
+  constructor (body) {
+    super(401, 'Unauthorized', body)
+  }
+}
+
+export class PaymentRequiredError extends HttpError {
+  constructor (body) {
+    super(402, 'Payment Required', body)
+  }
+}
+
+export class ForbiddenError extends HttpError {
+  constructor (body) {
+    super(403, 'Forbidden', body)
+  }
+}
+
+export class NotFoundError extends HttpError {
+  constructor (body) {
+    super(404, 'Not Found', body)
+  }
+}
+
+export class MethodNotAllowedError extends HttpError {
+  constructor (body) {
+    super(405, 'Method Not Allowed', body)
+  }
+}
+
+export class NotAcceptableError extends HttpError {
+  constructor (body) {
+    super(406, 'Not Acceptable', body)
+  }
+}
+
+export class ProxyAuthenticationRequiredError extends HttpError {
+  constructor (body) {
+    super(407, 'Proxy Authentication Required', body)
+  }
+}
+
+export class RequestTimeoutError extends HttpError {
+  constructor (body) {
+    super(408, 'Request Timeout', body)
+  }
+}
+
+export class ConflictError extends HttpError {
+  constructor (body) {
+    super(409, 'Conflict', body)
+  }
+}
+
+export class GoneError extends HttpError {
+  constructor (body) {
+    super(410, 'Gone', body)
+  }
+}
+
+export class LengthRequiredError extends HttpError {
+  constructor (body) {
+    super(411, 'Length Required', body)
+  }
+}
+
+export class PreconditionFailedError extends HttpError {
+  constructor (body) {
+    super(412, 'Precondition Failed', body)
+  }
+}
+
+export class PayloadTooLargeError extends HttpError {
+  constructor (body) {
+    super(413, 'Payload Too Large', body)
+  }
+}
+
+export class URITooLongError extends HttpError {
+  constructor (body) {
+    super(414, 'URI Too Long', body)
+  }
+}
+
+export class UnsupportedMediaTypeError extends HttpError {
+  constructor (body) {
+    super(415, 'Unsupported Media Type', body)
+  }
+}
+
+export class RangeNotSatisfiableError extends HttpError {
+  constructor (body) {
+    super(416, 'Bad Request', body)
+  }
+}
+
+export class ExpectationFailedError extends HttpError {
+  constructor (body) {
+    super(417, 'Expectation Failed', body)
+  }
+}
+
+export class ImATeapotError extends HttpError {
+  constructor (body) {
+    super(418, 'I can\'t brew coffee', body)
+  }
+}
+
+export class EnhanceYourCalmError extends HttpError {
+  constructor (body) {
+    super(420, 'Enhance Your Calm', body)
+  }
+}
+
+export class MisdirectedRequestError extends HttpError {
+  constructor (body) {
+    super(421, 'Misdirected Request', body)
+  }
+}
+
+export class UnprocessableEntityError extends HttpError {
+  constructor (body) {
+    super(422, 'Unprocessable Entity', body)
+  }
+}
+
+export class LockedError extends HttpError {
+  constructor (body) {
+    super(423, 'Locked', body)
+  }
+}
+
+export class FailedDependencyError extends HttpError {
+  constructor (body) {
+    super(424, 'Failed Dependency', body)
+  }
+}
+
+export class TooEarlyError extends HttpError {
+  constructor (body) {
+    super(425, 'Too Early', body)
+  }
+}
+
+export class UpgradeRequiredError extends HttpError {
+  constructor (body) {
+    super(426, 'Upgrade Required', body)
+  }
+}
+
+export class PreconditionRequiredError extends HttpError {
+  constructor (body) {
+    super(428, 'Precondition Required', body)
+  }
+}
+
+export class TooManyRequestsError extends HttpError {
+  constructor (body) {
+    super(429, 'Too Many Requests', body)
+  }
+}
+
+export class RequestHeaderFieldsTooLargeError extends HttpError {
+  constructor (body) {
+    super(431, 'Request Header Fields Too Large', body)
+  }
+}
+
+export class UnavailableForLegalReasonsError extends HttpError {
+  constructor (body) {
+    super(451, 'Unavailable For Legal Reasons', body)
+  }
+}
+
+export class InternalServerError extends HttpError {
+  constructor (body) {
+    super(500, 'Internal Server Error', body)
+  }
+}
+
+export class NotImplementedError extends HttpError {
+  constructor (body) {
+    super(501, 'Not Implemented', body)
+  }
+}
+
+export class BadGatewayError extends HttpError {
+  constructor (body) {
+    super(502, 'Bad Gateway', body)
+  }
+}
+
+export class ServiceUnavailableError extends HttpError {
+  constructor (body) {
+    super(503, 'Service Unavailable', body)
+  }
+}
+
+export class GatewayTimeoutError extends HttpError {
+  constructor (body) {
+    super(504, 'Gateway Timeout', body)
+  }
+}
+
+export class HTTPVersionNotSupportedError extends HttpError {
+  constructor (body) {
+    super(505, 'HTTP Version Not Supported', body)
+  }
+}
+
+export class VariantAlsoNegotiatesError extends HttpError {
+  constructor (body) {
+    super(506, 'Variant Also Negotiates', body)
+  }
+}
+
+export class InsufficientStorageError extends HttpError {
+  constructor (body) {
+    super(507, 'Insufficient Storage', body)
+  }
+}
+
+export class LoopDetectedError extends HttpError {
+  constructor (body) {
+    super(508, 'Loop Detected', body)
+  }
+}
+
+export class NotExtendedError extends HttpError {
+  constructor (body) {
+    super(510, 'Not Extended', body)
+  }
+}
+
+export class NetworkAuthenticationRequiredError extends HttpError {
+  constructor (body) {
+    super(511, 'Network Authentication Required', body)
+  }
+}

package/src/handler.mjs

@@ -34,7 +34,6 @@ const executeHandler = async (url, res, req, bodyPromise, handler, middleware, e
     finalizeResponse(req, res, handled, handler.statusCodeOverride)
   } catch (e) {
     const refId = uuid()
-    log.error('handler failed', e, refId)
     await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
     endError(res, e, refId, errorTransformer)
   }
@@ -174,7 +173,6 @@ const handleRequest = async (req, res, handler, middleware, errorTransformer) =>
     }
   } catch (e) {
     const refId = uuid()
-    log.error('Handling request failed', e, refId)
     await executeMiddleware(middleware, req, res, errorTransformer, refId, e)
     if (!res.writableEnded) { endError(res, e, refId, errorTransformer) }
   }

package/src/nodeModuleHandler.mjs

@@ -7,10 +7,18 @@ import { getContentTypeByExtension } from './content.mjs'
 const stripLeadingSlash = p => p.startsWith('/') ? p.substr(1) : p
 
 /**
- This method will add all of the configured node_module files to the given routes.
+ This helper will add all the configured node_module files to the given routes.
  The configured node moduleRoutes must be explicit files, no pattern matching is supported.
  Generating the list of files using pattern matching yourself is highly discouraged.
  It is much safer to explicitly list every file you wish to be served so you don't inadvertently serve additional files.
+
+ The default method is to read and serve directly from the node_modules directory without copying.
+ if method is set to "copy", files are copied from node_modules to their final location within the routes dir folder.
+
+ The primary benefit of using this in copy mode is that the files will be automatically updated when the package version
+ is updated, and it improves IDE integration by making the file really available after first run.
+
+ This could be destructive if not configured correctly, hence the default of read only
  */
 export function getNodeModuleRoutes (config) {
   const nodeModuleRoutes = config.nodeModuleRoutes
@@ -20,7 +28,7 @@ export function getNodeModuleRoutes (config) {
     if (!fs.existsSync(nodeModulesDir)) {
       throw new Error(`Unable to find node_modules dir at ${nodeModulesDir}`)
     }
-    const prefix = stripLeadingSlash(nodeModuleRoutes.routePrefix || 'lib')
+    const prefix = stripLeadingSlash(nodeModuleRoutes.routePrefix || 'lib/ext')
     if (!Array.isArray(nodeModuleRoutes.files)) {
       nodeModuleRoutes.files = [nodeModuleRoutes.files]
     }
@@ -37,21 +45,27 @@ export function getNodeModuleRoutes (config) {
       }
 
       if (fs.existsSync(filePath)) {
-        const parts = urlPath.split('/')
-        const lastPart = parts.pop()
-        const mw = {}
-        mergeMiddleware(config.middleware, mw)
-        mergeMiddleware(nodeModuleRoutes.middleware || {}, mw)
-        routes.push({
-          pathParameters: [],
-          urlPath,
-          filePath,
-          handlers: createStaticHandler(
-            filePath, getContentTypeByExtension(lastPart, config.staticContentTypes),
-            config.cacheStatic, config.staticCacheControl
-          ),
-          middleware: mw
-        })
+        if (nodeModuleRoutes.method === 'copy') {
+          const dest = path.join(config.routeDir, urlPath)
+          fs.mkdirSync(path.dirname(dest), { recursive: true })
+          fs.copyFileSync(filePath, dest)
+        } else {
+          const parts = urlPath.split('/')
+          const lastPart = parts.pop()
+          const mw = {}
+          mergeMiddleware(config.middleware, mw)
+          mergeMiddleware(nodeModuleRoutes.middleware || {}, mw)
+          routes.push({
+            pathParameters: [],
+            urlPath,
+            filePath,
+            handlers: createStaticHandler(
+              filePath, getContentTypeByExtension(lastPart, config.staticContentTypes),
+              config.cacheStatic, config.staticCacheControl
+            ),
+            middleware: mw
+          })
+        }
       } else {
         console.warn(`The specified node_modules file: ${file} does not exist and will not be served.`)
       }

package/src/server.mjs

@@ -68,7 +68,7 @@ const getHttpsApp = (key, cert) => {
 export async function startServer (config) {
   if (!state.initialized) {
     state.initialized = true
-    const routes = [...(await findRoutes(config)), ...getNodeModuleRoutes(config)]
+    const routes = [...getNodeModuleRoutes(config), ...(await findRoutes(config))]
     let app, port
     if (config.httpsKeyFile) {
       app = getHttpsApp(config.secure)