json-rest-api 1.0.22 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-rest-api",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "main": "index.js",
   "type": "module",
   "scripts": {
@@ -25,7 +25,7 @@
   "description": "REST API plugin for hooked-api with JSON:API compliance",
   "dependencies": {
     "hooked-api": "^1.0.24",
-    "json-rest-schema": "^1.0.12",
+    "json-rest-schema": "^1.0.13",
     "semver": "^7.7.2"
   },
   "peerDependencies": {

package/plugins/core/connectors/express-plugin.js

@@ -18,6 +18,20 @@ import { requirePackage } from 'hooked-api'
 import { parseJsonApiQuery } from '../lib/querying-writing/connectors-query-parser.js'
 import { createContext } from './lib/request-helpers.js'
 import { createEnhancedLogger } from '../../../lib/enhanced-logger.js'
+import {
+  isWriteMethod,
+  isAllowedWriteContentType,
+  getUnsupportedMediaTypeErrorBody
+} from './lib/transport-http-helpers.js'
+import {
+  extractQueryString,
+  buildTransportRequestData,
+  createConnectorContext,
+  runTransportRequestLifecycle,
+  buildTransportRejectionBody,
+  executeConnectorRoute,
+  handleConnectorError
+} from './lib/connector-core.js'
 
 export const ExpressPlugin = {
   name: 'express',
@@ -115,58 +129,39 @@ export const ExpressPlugin = {
 
     // Add transport hook middleware
     router.use(async (req, res, next) => {
-      const context = createContext(req, res, 'express')
-
-      // Check for Express middleware override first
-      if (req.urlPrefixOverride) {
-        context.urlPrefixOverride = req.urlPrefixOverride
-      }
-
-      // Calculate and cache URL prefix (getUrlPrefix handles all logic)
-      const { getUrlPrefix } = await import('../lib/querying/url-helpers.js')
-      context.urlPrefix = getUrlPrefix(context, { vars: { transport: { mountPath: basePath } } }, req)
-
-      // Transport-specific data for hooks
-      const transportData = {
-        request: {
-          method: req.method,
-          url: req.url,
-          path: req.path,
-          headers: req.headers,
-          body: req.body,
-          params: req.params,
-          query: req.query
-        },
-        response: {
-          headers: {},
-          status: null
-        }
-      }
-
-      // Add transport data to context
-      context.transport = transportData
-
-      // Run transport hooks - don't check return value for consistency with other hooks
-      // Hooks communicate via context flags (rejection, handled) not return values
-      await runHooks('transport:request', context)
+      const requestData = buildTransportRequestData({
+        method: req.method,
+        url: req.url,
+        path: req.path,
+        headers: req.headers,
+        body: req.body,
+        params: req.params,
+        query: req.query
+      })
+      const { context, transportData } = createConnectorContext({
+        request: req,
+        reply: res,
+        source: 'express',
+        mountPath: basePath,
+        requestData,
+        createContext,
+        urlPrefixOverride: req.urlPrefixOverride
+      })
+      const { rejected, handled } = await runTransportRequestLifecycle({
+        context,
+        runHooks
+      })
 
-      // Check if request was rejected (e.g., authentication failure)
-      if (context.rejection) {
-        // Apply response headers from hooks
+      if (rejected) {
         if (transportData.response.headers) {
           res.set(transportData.response.headers)
         }
-        return res.status(context.rejection.status || 500).json({
-          errors: [{
-            status: String(context.rejection.status || 500),
-            title: context.rejection.title || 'Request Rejected',
-            detail: context.rejection.message
-          }]
-        })
+        return res.status(context.rejection.status || 500).json(
+          buildTransportRejectionBody(context)
+        )
       }
 
-      // Check if request was already handled by a hook
-      if (context.handled) {
+      if (handled) {
         return
       }
 
@@ -179,18 +174,13 @@ export const ExpressPlugin = {
     // Content type validation middleware
     if (strictContentType) {
       router.use((req, res, next) => {
-        if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
+        if (isWriteMethod(req.method)) {
           const contentType = req.get('Content-Type')
 
-          if (contentType && !contentType.includes('application/vnd.api+json') &&
-              !contentType.includes('application/json') && !contentType.includes('multipart/form-data')) {
-            return res.status(415).json({
-              errors: [{
-                status: '415',
-                title: 'Unsupported Media Type',
-                detail: 'Content-Type must be application/vnd.api+json or application/json'
-              }]
-            })
+          if (!isAllowedWriteContentType(contentType, { allowMultipart: true })) {
+            return res.status(415).json(
+              getUnsupportedMediaTypeErrorBody({ allowMultipart: true })
+            )
           }
         }
         next()
@@ -207,77 +197,16 @@ export const ExpressPlugin = {
         url: req.url
       })
 
-      let status = 500
-      const errorResponse = {
-        errors: [{
-          status: '500',
-          title: 'Internal Server Error',
-          detail: error.message
-        }]
-      }
-
-      // Map error codes to HTTP status
-      if (error.code === 'REST_API_VALIDATION') {
-        status = 422
-        errorResponse.errors = [{
-          status: '422',
-          title: 'Validation Error',
-          detail: error.message,
-          source: error.details
-        }]
-        if (error.details?.violations) {
-          errorResponse.errors = error.details.violations.map(v => ({
-            status: '422',
-            title: 'Validation Error',
-            detail: v.message,
-            source: { pointer: v.field }
-          }))
-        }
-      } else if (error.code === 'REST_API_RESOURCE') {
-        switch (error.subtype) {
-          case 'not_found':
-            status = 404
-            errorResponse.errors[0].status = '404'
-            errorResponse.errors[0].title = 'Not Found'
-            break
-          case 'conflict':
-            status = 409
-            errorResponse.errors[0].status = '409'
-            errorResponse.errors[0].title = 'Conflict'
-            break
-          case 'forbidden':
-            status = 403
-            errorResponse.errors[0].status = '403'
-            errorResponse.errors[0].title = 'Forbidden'
-            break
-          default:
-            status = 400
-            errorResponse.errors[0].status = '400'
-            errorResponse.errors[0].title = 'Bad Request'
-        }
-      } else if (error.code === 'REST_API_PAYLOAD') {
-        status = 400
-        errorResponse.errors = [{
-          status: '400',
-          title: 'Bad Request',
-          detail: error.message,
-          source: { pointer: error.path }
-        }]
-      }
-
-      // Run transport:response hook for errors
-      if (req.transportData && req.context) {
-        req.transportData.response.status = status
-        req.transportData.response.body = errorResponse
-        req.context.transport = req.transportData
-        await runHooks('transport:response', req.context)
+      const { status, body: errorResponse, headers } = await handleConnectorError({
+        error,
+        context: req.context,
+        transportData: req.transportData,
+        runHooks
+      })
 
-        // Apply response headers from hooks
-        if (req.transportData.response.headers) {
-          res.set(req.transportData.response.headers)
-        }
+      if (headers) {
+        res.set(headers)
       }
-
       res.status(status).json(errorResponse)
     }
 
@@ -285,7 +214,7 @@ export const ExpressPlugin = {
      * Listen to addRoute hook to create Express routes
      */
     addHook('addRoute', 'expressRouteCreator', {}, async ({ context }) => {
-      const { method, path, handler } = context
+      const { method, path, handler, routeMeta } = context
 
       // Apply any global before middleware
       const beforeMiddleware = expressOptions.middleware?.beforeAll || []
@@ -294,78 +223,62 @@ export const ExpressPlugin = {
         // Extract the handler logic into a shared function to keep it DRY (Don't Repeat Yourself).
         const expressHandler = async (req, res) => {
           try {
-            // Extract request data
-            const queryString = req.url.split('?')[1] || ''
-            const context = req.context || createContext(req, res, 'express')
+            let context = req.context
+            let transportData = req.transportData
+
+            if (!context || !transportData) {
+              const requestData = buildTransportRequestData({
+                method: req.method,
+                url: req.url,
+                path: req.path,
+                headers: req.headers,
+                body: req.body,
+                params: req.params,
+                query: req.query
+              })
+              const setup = createConnectorContext({
+                request: req,
+                reply: res,
+                source: 'express',
+                mountPath: basePath,
+                requestData,
+                createContext,
+                urlPrefixOverride: req.urlPrefixOverride
+              })
+              context = setup.context
+              transportData = setup.transportData
+              req.context = context
+              req.transportData = transportData
+            }
 
-            // Call the generic handler
-            const result = await handler({
-              queryString,
+            const outcome = await executeConnectorRoute({
+              method: req.method,
+              handler,
+              queryString: extractQueryString(req.url),
               headers: req.headers,
               params: req.params,
               body: req.body,
-              context
+              context,
+              transportData,
+              routeMeta,
+              helpers,
+              mountPath: basePath,
+              runHooks
             })
-
-            // Prepare response status
-            let responseStatus = 200
-            if (result && typeof result.statusCode === 'number') {
-              responseStatus = result.statusCode
-            } else if (req.method === 'POST' && result) {
-              // POST with content returns 201 Created
-              responseStatus = 201
-            } else if (req.method === 'POST' && !result) {
-              // POST without content returns 204 No Content
-              responseStatus = 204
-            } else if (req.method === 'DELETE') {
-              // DELETE always returns 204 No Content
-              responseStatus = 204
-            } else if ((req.method === 'PUT' || req.method === 'PATCH') && !result) {
-              // PUT/PATCH return 204 when no content is returned
-              responseStatus = 204
-            }
-
-            // Apply headers from the handler result
-            if (result && result.headers) {
-              res.set(result.headers)
-            }
-
-            // Update transport data for response (if transport data exists)
-            if (req.transportData) {
-              req.transportData.response.status = responseStatus
-              req.transportData.response.body = result
-              context.transport = req.transportData
-              await runHooks('transport:response', context)
-              if (req.transportData.response.headers) {
-                res.set(req.transportData.response.headers)
-              }
-            }
+            res.set(outcome.headers)
 
             // Set content type
             res.set('Content-Type', 'application/vnd.api+json')
 
-            // Set Location header for successful POST requests
-            if (req.method === 'POST' && context.id) {
-              // Extract scopeName from the path (e.g., /api/countries -> countries)
-              const pathParts = path.split('/')
-              const scopeName = pathParts[pathParts.length - 1]
-
-              // Set Location header for any successful POST (201 or 204)
-              if (helpers.getLocation) {
-                const location = helpers.getLocation({ scopeName, id: context.id })
-                const baseUrl = context.urlPrefix || basePath
-                res.set('Location', `${baseUrl}${location}`)
-              }
+            if (outcome.location) {
+              res.set('Location', outcome.location)
             }
 
             // Handle response based on status
-            if (responseStatus === 204) {
+            if (outcome.status === 204) {
               res.sendStatus(204)
             } else {
-              // If result has a body property, that's what we should send
-              // This happens when handler returns { statusCode, body, headers }
-              const responseBody = result && result.body !== undefined ? result.body : result
-              res.status(responseStatus).json(responseBody)
+              res.status(outcome.status).json(outcome.body)
             }
           } catch (error) {
             handleError(error, req, res)

package/plugins/core/connectors/fastify-plugin.js

@@ -0,0 +1,206 @@
+import { createContext } from './lib/request-helpers.js'
+import { createEnhancedLogger } from '../../../lib/enhanced-logger.js'
+import { buildTransportRouteSchema } from './lib/transport-route-schemas.js'
+import {
+  isWriteMethod,
+  isAllowedWriteContentType,
+  getUnsupportedMediaTypeErrorBody
+} from './lib/transport-http-helpers.js'
+import {
+  extractQueryString,
+  buildTransportRequestData,
+  createConnectorContext,
+  runTransportRequestLifecycle,
+  buildTransportRejectionBody,
+  executeConnectorRoute,
+  handleConnectorError
+} from './lib/connector-core.js'
+
+function applyHeaders (reply, headers = {}) {
+  for (const [headerName, headerValue] of Object.entries(headers)) {
+    reply.header(headerName, headerValue)
+  }
+}
+
+function registerVendorJsonParser (app) {
+  if (typeof app?.addContentTypeParser !== 'function') return
+  if (typeof app?.hasContentTypeParser === 'function' && app.hasContentTypeParser('application/vnd.api+json')) {
+    return
+  }
+
+  app.addContentTypeParser(
+    'application/vnd.api+json',
+    { parseAs: 'string' },
+    (request, body, done) => {
+      if (body === '' || body === undefined || body === null) {
+        done(null, {})
+        return
+      }
+
+      try {
+        done(null, JSON.parse(body))
+      } catch (error) {
+        error.statusCode = 400
+        done(error)
+      }
+    }
+  )
+}
+
+export const FastifyPlugin = {
+  name: 'fastify',
+  dependencies: ['rest-api'],
+
+  async install ({ vars, helpers, pluginOptions, log, api, runHooks, addHook }) {
+    const fastifyOptions = pluginOptions || {}
+    const app = fastifyOptions.app
+
+    if (!app || typeof app.route !== 'function') {
+      throw new Error('FastifyPlugin requires a Fastify instance in pluginOptions.app.')
+    }
+
+    const enhancedLog = createEnhancedLogger(log, {
+      logFullErrors: true,
+      includeStack: true
+    })
+
+    if (!api.http) {
+      api.http = {}
+    }
+    api.http.fastify = { app }
+
+    const mountPath = fastifyOptions.mountPath || ''
+    const strictContentType = fastifyOptions.strictContentType !== false
+
+    vars.transport = {
+      type: 'fastify',
+      matchAll: '*',
+      mountPath
+    }
+
+    registerVendorJsonParser(app)
+
+    const buildFastifyHandler = ({ method, path, handler, routeMeta }) => {
+      const routeSchema = buildTransportRouteSchema({ routeMeta, api })
+
+      const fastifyErrorHandler = async (error, request, reply) => {
+        enhancedLog.logError('Fastify request error', error, {
+          method: request.method,
+          path: request.url
+        })
+
+        const context = request.jsonRestContext || null
+        const transportData = context?.transport || null
+        const { status, body, headers } = await handleConnectorError({
+          error,
+          context,
+          transportData,
+          runHooks
+        })
+
+        applyHeaders(reply, headers)
+        reply.code(status)
+        reply.type('application/vnd.api+json')
+        return reply.send(body)
+      }
+
+      const preValidation = async (request, reply) => {
+        if (!strictContentType || !isWriteMethod(method)) {
+          return
+        }
+
+        const contentType = request.headers?.['content-type'] || ''
+        if (isAllowedWriteContentType(contentType)) {
+          return
+        }
+
+        reply.code(415)
+        reply.type('application/vnd.api+json')
+        return reply.send(getUnsupportedMediaTypeErrorBody())
+      }
+
+      return {
+        method,
+        url: path,
+        ...(routeSchema ? { schema: routeSchema } : {}),
+        errorHandler: fastifyErrorHandler,
+        preValidation,
+        handler: async (request, reply) => {
+          const requestData = buildTransportRequestData({
+            method: request.method,
+            url: request.url,
+            path: request.url,
+            headers: request.headers,
+            body: request.body,
+            params: request.params,
+            query: request.query
+          })
+          const { context, transportData } = createConnectorContext({
+            request,
+            reply,
+            source: 'fastify',
+            mountPath,
+            requestData,
+            createContext
+          })
+          request.jsonRestContext = context
+
+          const { rejected, handled } = await runTransportRequestLifecycle({
+            context,
+            runHooks
+          })
+
+          if (rejected) {
+            const rejectionBody = buildTransportRejectionBody(context)
+            applyHeaders(reply, transportData.response.headers)
+            reply.code(context.rejection.status || 500)
+            reply.type('application/vnd.api+json')
+            return reply.send(rejectionBody)
+          }
+
+          if (handled) {
+            return
+          }
+
+          const outcome = await executeConnectorRoute({
+            method,
+            handler,
+            queryString: extractQueryString(request?.raw?.url || request?.url || ''),
+            headers: request.headers,
+            params: request.params,
+            body: request.body,
+            context,
+            transportData,
+            routeMeta,
+            helpers,
+            mountPath,
+            runHooks
+          })
+
+          applyHeaders(reply, outcome.headers)
+          reply.type('application/vnd.api+json')
+
+          if (outcome.location) {
+            reply.header('Location', outcome.location)
+          }
+
+          if (outcome.status === 204) {
+            reply.code(204)
+            return reply.send()
+          }
+
+          reply.code(outcome.status)
+          return reply.send(outcome.body)
+        }
+      }
+    }
+
+    addHook('addRoute', 'fastifyRouteCreator', {}, async ({ context }) => {
+      const route = buildFastifyHandler(context)
+      app.route(route)
+      log.trace(`Fastify route created: ${context.method} ${context.path}`)
+    })
+
+    log.info('Fastify plugin initialized successfully')
+  }
+}