json-rest-api 1.0.23 → 1.0.25

package/plugins/core/bulk-operations-plugin.js

@@ -1,4 +1,4 @@
-import { RestApiValidationError, RestApiResourceError } from '../../lib/rest-api-errors.js'
+import { RestApiValidationError } from '../../lib/rest-api-errors.js'
 
 export const BulkOperationsPlugin = {
   name: 'bulk-operations',
@@ -193,11 +193,12 @@ export const BulkOperationsPlugin = {
               transaction
             }, recordContext)
 
-            // If patch doesn't return full record, fetch it
-            let resultData = result.data
-            if (!resultData && result.id) {
+            // If patch doesn't return a full record, fetch the updated record.
+            const resultId = result?.data?.id || result?.id || operation.id
+            let resultData = result?.data
+            if (!resultData && resultId) {
               const fetchedRecord = await scope.get({
-                id: result.id,
+                id: resultId,
                 transaction
               }, recordContext)
               resultData = fetchedRecord.data
@@ -353,41 +354,33 @@ export const BulkOperationsPlugin = {
       // Create route handlers
       const createBulkRouteHandler = (method) => {
         return async ({ context, body, query }) => {
-          try {
-            // Parse query params for atomic mode override
-            const atomic = query?.atomic !== undefined
-              ? query.atomic === 'true'
-              : defaultAtomic
-
-            let params
-            if (method === 'bulkPost') {
-              // For bulk create, expect array in data field (JSON:API style)
-              params = {
-                inputRecords: body?.data || body,
-                atomic
-              }
-            } else if (method === 'bulkPatch') {
-              // For bulk update, expect operations array
-              params = {
-                operations: body?.operations || body,
-                atomic
-              }
-            } else if (method === 'bulkDelete') {
-              // For bulk delete, expect IDs array
-              params = {
-                ids: body?.data || body?.ids || body,
-                atomic
-              }
+          // Parse query params for atomic mode override
+          const atomic = query?.atomic !== undefined
+            ? query.atomic === 'true'
+            : defaultAtomic
+
+          let params
+          if (method === 'bulkPost') {
+            // For bulk create, expect array in data field (JSON:API style)
+            params = {
+              inputRecords: body?.data || body,
+              atomic
+            }
+          } else if (method === 'bulkPatch') {
+            // For bulk update, expect operations array
+            params = {
+              operations: body?.operations || body,
+              atomic
+            }
+          } else if (method === 'bulkDelete') {
+            // For bulk delete, expect IDs array
+            params = {
+              ids: body?.data || body?.ids || body,
+              atomic
             }
-
-            // Call the scope method
-            const result = await api.scopes[scopeName][method](params)
-
-            return result
-          } catch (error) {
-            // Let transport plugin handle error mapping
-            throw error
           }
+
+          return await api.scopes[scopeName][method](params)
         }
       }
 

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

@@ -15,7 +15,6 @@
  */
 
 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 {
@@ -67,6 +66,7 @@ export const ExpressPlugin = {
     // Get mountPath from options (this is now a transport concern)
     const mountPath = expressOptions.mountPath || ''
     const basePath = mountPath // Keep basePath for internal use
+    const publicBaseUrl = expressOptions.publicBaseUrl || ''
     const strictContentType = expressOptions.strictContentType !== false
     const requestSizeLimit = expressOptions.requestSizeLimit || '1mb'
 
@@ -74,7 +74,8 @@ export const ExpressPlugin = {
     vars.transport = {
       type: 'express',
       matchAll: '*', // Express wildcard pattern for matching all routes
-      mountPath // Transport-specific mount path
+      mountPath, // Transport-specific mount path
+      publicBaseUrl
     }
 
     // Register file detector if enabled
@@ -143,6 +144,7 @@ export const ExpressPlugin = {
         reply: res,
         source: 'express',
         mountPath: basePath,
+        publicBaseUrl,
         requestData,
         createContext,
         urlPrefixOverride: req.urlPrefixOverride
@@ -241,6 +243,7 @@ export const ExpressPlugin = {
                 reply: res,
                 source: 'express',
                 mountPath: basePath,
+                publicBaseUrl,
                 requestData,
                 createContext,
                 urlPrefixOverride: req.urlPrefixOverride
@@ -263,6 +266,7 @@ export const ExpressPlugin = {
               routeMeta,
               helpers,
               mountPath: basePath,
+              publicBaseUrl,
               runHooks
             })
             res.set(outcome.headers)
@@ -337,11 +341,6 @@ export const ExpressPlugin = {
           router[method.toLowerCase()](path, ...beforeMiddleware, expressHandler)
 
           // Debug logging for route registration
-
-          // Check if the route was actually added
-          if (router.stack) {
-            const lastRoute = router.stack[router.stack.length - 1]
-          }
         }
       } catch (routeError) {
         log.error('[EXPRESS DEBUG] Error creating route:', {

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

@@ -70,12 +70,14 @@ export const FastifyPlugin = {
     api.http.fastify = { app }
 
     const mountPath = fastifyOptions.mountPath || ''
+    const publicBaseUrl = fastifyOptions.publicBaseUrl || ''
     const strictContentType = fastifyOptions.strictContentType !== false
 
     vars.transport = {
       type: 'fastify',
       matchAll: '*',
-      mountPath
+      mountPath,
+      publicBaseUrl
     }
 
     registerVendorJsonParser(app)
@@ -140,6 +142,7 @@ export const FastifyPlugin = {
             reply,
             source: 'fastify',
             mountPath,
+            publicBaseUrl,
             requestData,
             createContext
           })
@@ -174,6 +177,7 @@ export const FastifyPlugin = {
             routeMeta,
             helpers,
             mountPath,
+            publicBaseUrl,
             runHooks
           })
 

package/plugins/core/connectors/lib/busboy-detector.js

@@ -101,14 +101,14 @@ export function createBusboyDetector (options = {}) {
           const chunks = []
           let size = 0
 
-          const filePromise = new Promise((fileResolve, fileReject) => {
+          const filePromise = new Promise((resolve, reject) => {
             file.on('data', (chunk) => {
               chunks.push(chunk)
               size += chunk.length
             })
 
             file.on('limit', () => {
-              fileReject(new Error(`File size limit exceeded for field '${fieldname}'`))
+              reject(new Error(`File size limit exceeded for field '${fieldname}'`))
             })
 
             file.on('end', () => {
@@ -119,10 +119,10 @@ export function createBusboyDetector (options = {}) {
                 size,
                 data: Buffer.concat(chunks)
               }
-              fileResolve()
+              resolve()
             })
 
-            file.on('error', fileReject)
+            file.on('error', reject)
           })
 
           filePromises.push(filePromise)

package/plugins/core/connectors/lib/connector-core.js

@@ -43,6 +43,7 @@ export function createConnectorContext ({
   reply,
   source,
   mountPath = '',
+  publicBaseUrl = '',
   requestData,
   createContext,
   urlPrefixOverride
@@ -55,8 +56,7 @@ export function createConnectorContext ({
 
   context.urlPrefix = getUrlPrefix(
     context,
-    { vars: { transport: { mountPath } } },
-    request
+    { vars: { transport: { mountPath, publicBaseUrl } } }
   )
 
   const transportData = buildTransportData(requestData)
@@ -113,7 +113,8 @@ export function getConnectorLocationHeader ({
   context,
   routeMeta,
   helpers,
-  mountPath = ''
+  mountPath = '',
+  publicBaseUrl = ''
 }) {
   if (String(method || '').toUpperCase() !== 'POST') return null
   if (!context?.id || !routeMeta?.scopeName || !helpers?.getLocation) return null
@@ -123,7 +124,9 @@ export function getConnectorLocationHeader ({
     id: context.id
   })
 
-  const baseUrl = context.urlPrefix || mountPath
+  const baseUrl = getUrlPrefix(context, {
+    vars: { transport: { mountPath, publicBaseUrl } }
+  })
   return `${baseUrl}${location}`
 }
 
@@ -139,6 +142,7 @@ export async function executeConnectorRoute ({
   routeMeta,
   helpers,
   mountPath = '',
+  publicBaseUrl = '',
   runHooks
 }) {
   const result = await handler({
@@ -150,6 +154,14 @@ export async function executeConnectorRoute ({
   })
 
   const status = determineResponseStatus(method, result)
+  const location = getConnectorLocationHeader({
+    method,
+    context,
+    routeMeta,
+    helpers,
+    mountPath,
+    publicBaseUrl
+  })
   const transportHeaders = await applyTransportResponseLifecycle({
     context,
     transportData,
@@ -165,13 +177,7 @@ export async function executeConnectorRoute ({
       ...(result?.headers || {}),
       ...transportHeaders
     },
-    location: getConnectorLocationHeader({
-      method,
-      context,
-      routeMeta,
-      helpers,
-      mountPath
-    }),
+    location,
     result
   }
 }

package/plugins/core/connectors/lib/transport-route-schemas.js

@@ -1,70 +1,11 @@
 import { getRequestContracts } from '../../lib/querying-writing/request-contracts.js'
 
-const STRING_OR_NUMBER_SCHEMA = {
-  anyOf: [
-    { type: 'string' },
-    { type: 'number' }
-  ]
-}
-
-function buildResourceIdentifierSchema () {
-  return {
-    type: 'object',
-    additionalProperties: false,
-    required: ['type', 'id'],
-    properties: {
-      type: { type: 'string', minLength: 1 },
-      id: STRING_OR_NUMBER_SCHEMA
-    }
-  }
-}
-
-function buildRelationshipValueSchema (operation) {
-  if (operation === 'patchRelationship') {
-    return {
-      anyOf: [
-        { type: 'null' },
-        buildResourceIdentifierSchema(),
-        {
-          type: 'array',
-          items: buildResourceIdentifierSchema()
-        }
-      ]
-    }
-  }
-
-  return {
-    type: 'array',
-    items: buildResourceIdentifierSchema()
-  }
-}
-
-function buildRelationshipRouteBodySchema (operation) {
-  if (!['postRelationship', 'patchRelationship', 'deleteRelationship'].includes(operation)) {
-    return null
-  }
-
-  return {
-    type: 'object',
-    additionalProperties: false,
-    required: ['data'],
-    properties: {
-      data: buildRelationshipValueSchema(operation)
-    }
-  }
-}
-
 export function buildTransportRouteSchema ({ routeMeta, api }) {
   if (!routeMeta) {
     return null
   }
 
-  if (routeMeta.kind === 'relationship') {
-    const relationshipBodySchema = buildRelationshipRouteBodySchema(routeMeta.operation)
-    return relationshipBodySchema ? { body: relationshipBodySchema } : null
-  }
-
-  if (routeMeta.kind !== 'resource' || !['post', 'put', 'patch'].includes(routeMeta.operation)) {
+  if (!['resource', 'relationship'].includes(routeMeta.kind)) {
     return null
   }
 
@@ -86,6 +27,17 @@ export function buildTransportRouteSchema ({ routeMeta, api }) {
     return null
   }
 
+  if (routeMeta.kind === 'resource' && !['post', 'put', 'patch'].includes(routeMeta.operation)) {
+    return null
+  }
+
+  if (
+    routeMeta.kind === 'relationship' &&
+    !['postRelationship', 'patchRelationship', 'deleteRelationship'].includes(routeMeta.operation)
+  ) {
+    return null
+  }
+
   return {
     body: contract.schema.toJsonSchema({ mode: contract.mode, additionalProperties: false })
   }

package/plugins/core/file-handling-plugin.js

@@ -65,6 +65,43 @@ export const FileHandlingPlugin = {
     // Store detectors array for inspection
     api.rest.fileDetectors = detectorRegistry
 
+    const trackUploadedFile = (context, upload) => {
+      if (!context.fileHandlingUploads) {
+        context.fileHandlingUploads = []
+      }
+      context.fileHandlingUploads.push(upload)
+    }
+
+    const cleanupParsedFiles = async (files = {}) => {
+      for (const file of Object.values(files)) {
+        if (!file?.cleanup) continue
+
+        try {
+          await file.cleanup()
+        } catch (error) {
+          log.warn('Failed to cleanup temp file:', error)
+        }
+      }
+    }
+
+    const cleanupUploadedFiles = async (context) => {
+      const uploads = context.fileHandlingUploads
+      if (!uploads || uploads.length === 0) return
+
+      context.fileHandlingUploads = []
+      for (const upload of uploads) {
+        if (!upload?.url || typeof upload.storage?.delete !== 'function') {
+          continue
+        }
+
+        try {
+          await upload.storage.delete(upload.url)
+        } catch (error) {
+          log.warn(`Failed to cleanup uploaded file '${upload.url}' after rollback:`, error)
+        }
+      }
+    }
+
     /**
      * Analyze a scope's schema to find file fields
      */
@@ -152,125 +189,114 @@ export const FileHandlingPlugin = {
       }
 
       log.debug(`Processing files with detector '${detectorUsed}'`)
-      const { fields, files } = parsed
+      const { fields = {}, files = {} } = parsed
 
-      // Process each file field defined in schema
-      for (const fieldConfig of fileFields) {
-        const file = files[fieldConfig.field]
+      try {
+        // Process each file field defined in schema
+        for (const fieldConfig of fileFields) {
+          const file = files[fieldConfig.field]
+
+          if (!file) {
+            if (fieldConfig.required) {
+              throw new RestApiValidationError(
+                `Required file field '${fieldConfig.field}' is missing`,
+                {
+                  fields: [fieldConfig.field],
+                  violations: [{
+                    field: fieldConfig.field,
+                    message: 'This field is required'
+                  }]
+                }
+              )
+            }
+            continue
+          }
 
-        if (!file) {
-          if (fieldConfig.required) {
-            throw new RestApiValidationError(
-              `Required file field '${fieldConfig.field}' is missing`,
-              {
-                fields: [fieldConfig.field],
-                violations: [{
-                  field: fieldConfig.field,
-                  message: 'This field is required'
-                }]
+          // Validate mime type
+          if (fieldConfig.accepts[0] !== '*') {
+            const acceptable = fieldConfig.accepts.some(pattern => {
+              if (pattern.endsWith('/*')) {
+                // e.g., 'image/*'
+                const prefix = pattern.slice(0, -2)
+                return file.mimetype.startsWith(prefix + '/')
               }
-            )
+              return file.mimetype === pattern
+            })
+
+            if (!acceptable) {
+              throw new RestApiValidationError(
+                `Invalid file type for field '${fieldConfig.field}'`,
+                {
+                  fields: [fieldConfig.field],
+                  violations: [{
+                    field: fieldConfig.field,
+                    message: `Expected ${fieldConfig.accepts.join(' or ')}, got ${file.mimetype}`
+                  }]
+                }
+              )
+            }
           }
-          continue
-        }
 
-        // Validate mime type
-        if (fieldConfig.accepts[0] !== '*') {
-          const acceptable = fieldConfig.accepts.some(pattern => {
-            if (pattern.endsWith('/*')) {
-              // e.g., 'image/*'
-              const prefix = pattern.slice(0, -2)
-              return file.mimetype.startsWith(prefix + '/')
+          // Validate file size
+          if (fieldConfig.maxSize) {
+            const maxBytes = parseSize(fieldConfig.maxSize)
+            if (file.size > maxBytes) {
+              throw new RestApiValidationError(
+                `File too large for field '${fieldConfig.field}'`,
+                {
+                  fields: [fieldConfig.field],
+                  violations: [{
+                    field: fieldConfig.field,
+                    message: `Maximum size is ${fieldConfig.maxSize}, got ${formatSize(file.size)}`
+                  }]
+                }
+              )
             }
-            return file.mimetype === pattern
-          })
+          }
 
-          if (!acceptable) {
-            throw new RestApiValidationError(
-              `Invalid file type for field '${fieldConfig.field}'`,
-              {
-                fields: [fieldConfig.field],
-                violations: [{
-                  field: fieldConfig.field,
-                  message: `Expected ${fieldConfig.accepts.join(' or ')}, got ${file.mimetype}`
-                }]
-              }
-            )
+          // Upload to storage
+          if (!fieldConfig.storage) {
+            throw new Error(`No storage configured for file field '${fieldConfig.field}'`)
           }
-        }
 
-        // Validate file size
-        if (fieldConfig.maxSize) {
-          const maxBytes = parseSize(fieldConfig.maxSize)
-          if (file.size > maxBytes) {
+          try {
+            const storedUrl = await fieldConfig.storage.upload(file)
+            fields[fieldConfig.field] = storedUrl
+            trackUploadedFile(context, {
+              field: fieldConfig.field,
+              storage: fieldConfig.storage,
+              url: storedUrl
+            })
+            log.debug(`Uploaded file for field '${fieldConfig.field}' to: ${storedUrl}`)
+          } catch (error) {
             throw new RestApiValidationError(
-              `File too large for field '${fieldConfig.field}'`,
+              `Failed to upload file for field '${fieldConfig.field}': ${error.message}`,
               {
                 fields: [fieldConfig.field],
                 violations: [{
                   field: fieldConfig.field,
-                  message: `Maximum size is ${fieldConfig.maxSize}, got ${formatSize(file.size)}`
+                  message: error.message
                 }]
               }
             )
           }
         }
 
-        // Upload to storage
-        if (!fieldConfig.storage) {
-          throw new Error(`No storage configured for file field '${fieldConfig.field}'`)
+        // Replace inputRecord with processed data
+        if (!params.inputRecord) {
+          params.inputRecord = { data: { attributes: {} } }
         }
-
-        try {
-          const storedUrl = await fieldConfig.storage.upload(file)
-          fields[fieldConfig.field] = storedUrl
-          log.debug(`Uploaded file for field '${fieldConfig.field}' to: ${storedUrl}`)
-        } catch (error) {
-          // Cleanup if file has cleanup function
-          if (file.cleanup) {
-            try {
-              await file.cleanup()
-            } catch (cleanupError) {
-              log.warn('Failed to cleanup file after upload error:', cleanupError)
-            }
-          }
-
-          throw new RestApiValidationError(
-            `Failed to upload file for field '${fieldConfig.field}': ${error.message}`,
-            {
-              fields: [fieldConfig.field],
-              violations: [{
-                field: fieldConfig.field,
-                message: error.message
-              }]
-            }
-          )
+        if (!params.inputRecord.data) {
+          params.inputRecord.data = { attributes: {} }
         }
-      }
-
-      // Replace inputRecord with processed data
-      if (!params.inputRecord) {
-        params.inputRecord = { data: { attributes: {} } }
-      }
-      if (!params.inputRecord.data) {
-        params.inputRecord.data = { attributes: {} }
-      }
-      if (!params.inputRecord.data.attributes) {
-        params.inputRecord.data.attributes = {}
-      }
-
-      // Merge fields into attributes
-      Object.assign(params.inputRecord.data.attributes, fields)
-
-      // Cleanup any remaining temp files
-      for (const file of Object.values(files)) {
-        if (file.cleanup) {
-          try {
-            await file.cleanup()
-          } catch (error) {
-            log.warn('Failed to cleanup temp file:', error)
-          }
+        if (!params.inputRecord.data.attributes) {
+          params.inputRecord.data.attributes = {}
         }
+
+        // Merge fields into attributes
+        Object.assign(params.inputRecord.data.attributes, fields)
+      } finally {
+        await cleanupParsedFiles(files)
       }
     }
 
@@ -291,6 +317,10 @@ export const FileHandlingPlugin = {
       await processFiles(scopeName, params, context)
     })
 
+    addHook('afterRollback', 'cleanupUploadedFiles', {}, async ({ context }) => {
+      await cleanupUploadedFiles(context)
+    })
+
     log.info('File handling plugin initialized successfully')
   }
 }