json-rest-api 1.0.24 → 1.0.25

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')
   }
 }

package/plugins/core/lib/anyapi/anyapi-registry.js

@@ -9,6 +9,21 @@ const clone = (value) => {
 
 const SUPPORTED_TYPES = new Set([...TYPE_TO_POOL.keys(), 'id'])
 
+const resolveIdProperty = (schema = {}, explicitIdProperty = null) => {
+  if (explicitIdProperty) return explicitIdProperty
+  if (schema.id) return 'id'
+
+  const idFields = Object.entries(schema)
+    .filter(([, fieldDef]) => (
+      fieldDef?.type === 'id' &&
+      !fieldDef.belongsTo &&
+      !fieldDef.belongsToPolymorphic
+    ))
+    .map(([fieldName]) => fieldName)
+
+  return idFields.length === 1 ? idFields[0] : 'id'
+}
+
 const BELONGS_TO_ALIAS = (fieldName, fieldDef) => {
   if (fieldDef.as) return fieldDef.as
   if (fieldName.endsWith('_id')) {
@@ -305,6 +320,7 @@ export class AnyapiRegistry {
 
   async #register (definition, externalTrx) {
     const { tenant, resource, schema, relationships = {}, canonicalFieldMap = null } = definition
+    const idProperty = resolveIdProperty(schema, definition.idProperty)
     const trx = externalTrx || await this.knex.transaction()
     const managed = !externalTrx
 
@@ -520,7 +536,7 @@ export class AnyapiRegistry {
         await trx('any_relationship_configs').insert(relationshipInserts)
       }
 
-      const descriptor = await this.#loadDescriptor(tenant, resource, trx)
+      const descriptor = await this.#loadDescriptor(tenant, resource, trx, { idProperty })
 
       if (managed) {
         await trx.commit()
@@ -535,7 +551,7 @@ export class AnyapiRegistry {
     }
   }
 
-  async #loadDescriptor (tenant, resource, trx) {
+  async #loadDescriptor (tenant, resource, trx, options = {}) {
     const query = (trx || this.knex)('any_resource_configs')
       .where({ tenant_id: tenant, resource })
       .first()
@@ -568,6 +584,7 @@ export class AnyapiRegistry {
       slotState,
       fieldRows,
       relationshipRows,
+      idProperty: options.idProperty,
     })
 
     const canonicalFieldMap = {}
@@ -589,7 +606,7 @@ export class AnyapiRegistry {
     return descriptor
   }
 
-  #buildDescriptor ({ tenant, resource, schema, relationships, slotState, fieldRows, relationshipRows }) {
+  #buildDescriptor ({ tenant, resource, schema, relationships, slotState, fieldRows, relationshipRows, idProperty }) {
     const fields = {}
     const reverseAttributes = {}
     const belongsTo = {}
@@ -671,6 +688,7 @@ export class AnyapiRegistry {
     return {
       tenant,
       resource,
+      idProperty: resolveIdProperty(schema, idProperty),
       schema,
       relationships,
       canonical: DEFAULT_CANONICAL_CONFIG,

package/plugins/core/lib/anyapi/schema-utils.js

@@ -210,6 +210,7 @@ export const TYPE_TO_POOL = new Map([
   ['text', 'string'],
   ['uuid', 'string'],
   ['email', 'string'],
+  ['file', 'string'],
   ['number', 'number'],
   ['integer', 'number'],
   ['float', 'number'],

package/plugins/core/lib/anyapi/utils/descriptor-helpers.js

@@ -1,4 +1,5 @@
 import { RestApiValidationError } from '../../../../../lib/rest-api-errors.js'
+import { normalizeDateValue } from '../../querying-writing/database-value-normalizers.js'
 
 export const normalizeId = (value) => (value === null || value === undefined ? null : String(value))
 
@@ -21,7 +22,8 @@ export const findSchemaFieldByAlias = (descriptor, alias) => {
 
 export const resolveFieldInfo = (descriptor, field) => {
   if (!descriptor) return null
-  if (field === 'id') {
+  const idProperty = descriptor.idProperty || 'id'
+  if (field === 'id' || field === idProperty) {
     return {
       column: descriptor?.canonical?.logicalIdColumn || 'logical_id',
       definition: { type: 'id' }
@@ -90,6 +92,10 @@ export const coerceValueForDefinition = (value, definition, { isRelationship } =
     return String(value)
   }
 
+  if (['date', 'dateTime', 'time'].includes(type)) {
+    return normalizeDateValue(value, type)
+  }
+
   return value
 }
 

package/plugins/core/lib/querying/knex-json-api-transformers-querying.js

@@ -350,37 +350,42 @@ export const toJsonApiRecord = (scope, record, scopeName) => {
 export const buildJsonApiResponse = async (scope, records, included = [], isSingle = false, scopeName, context) => {
   const {
     vars: {
-      schemaInfo: { schemaInstance, schemaRelationships: relationships, idProperty }
+      schemaInfo
     }
   } = scope
 
-  const idField = idProperty || 'id'
+  const {
+    schemaInstance,
+    schemaRelationships: relationships
+  } = schemaInfo
 
   const schemaStructure = getSchemaStructure(schemaInstance)
 
   const processedRecords = records.map(record => {
     const { [RELATIONSHIPS_KEY]: _relationships, ...cleanRecord } = record
+    const logicalRecord = translateRecordFromStorage(cleanRecord, schemaInfo)
     const jsonApiRecord = toJsonApiRecord(scope, cleanRecord, scopeName)
+    const resourceId = jsonApiRecord.id
 
     if (_relationships) {
       jsonApiRecord.relationships = _relationships
     }
 
     for (const [fieldName, fieldDef] of Object.entries(schemaStructure)) {
-      if (fieldDef.belongsTo && fieldDef.as && fieldName in cleanRecord) {
+      if (fieldDef.belongsTo && fieldDef.as && fieldName in logicalRecord) {
         jsonApiRecord.relationships = jsonApiRecord.relationships || {}
         if (!jsonApiRecord.relationships[fieldDef.as]) {
-          if (cleanRecord[fieldName] !== null && cleanRecord[fieldName] !== undefined) {
+          if (logicalRecord[fieldName] !== null && logicalRecord[fieldName] !== undefined) {
             const relationshipObject = {
               data: {
                 type: fieldDef.belongsTo,
-                id: String(cleanRecord[fieldName])
+                id: String(logicalRecord[fieldName])
               }
             }
 
             relationshipObject.links = {
-              self: buildRelationshipUrl(context, scope, scopeName, record[idField], fieldDef.as, true),
-              related: buildRelationshipUrl(context, scope, scopeName, record[idField], fieldDef.as, false)
+              self: buildRelationshipUrl(context, scope, scopeName, resourceId, fieldDef.as, true),
+              related: buildRelationshipUrl(context, scope, scopeName, resourceId, fieldDef.as, false)
             }
 
             jsonApiRecord.relationships[fieldDef.as] = relationshipObject
@@ -390,8 +395,8 @@ export const buildJsonApiResponse = async (scope, records, included = [], isSing
             }
 
             relationshipObject.links = {
-              self: buildRelationshipUrl(context, scope, scopeName, record[idField], fieldDef.as, true),
-              related: buildRelationshipUrl(context, scope, scopeName, record[idField], fieldDef.as, false)
+              self: buildRelationshipUrl(context, scope, scopeName, resourceId, fieldDef.as, true),
+              related: buildRelationshipUrl(context, scope, scopeName, resourceId, fieldDef.as, false)
             }
 
             jsonApiRecord.relationships[fieldDef.as] = relationshipObject
@@ -402,8 +407,8 @@ export const buildJsonApiResponse = async (scope, records, included = [], isSing
 
     Object.entries(relationships || {}).forEach(([relName, relDef]) => {
       if (relDef.belongsToPolymorphic) {
-        const typeValue = cleanRecord[relDef.belongsToPolymorphic.typeField]
-        const idValue = cleanRecord[relDef.belongsToPolymorphic.idField]
+        const typeValue = logicalRecord[relDef.belongsToPolymorphic.typeField]
+        const idValue = logicalRecord[relDef.belongsToPolymorphic.idField]
 
         if (typeValue && idValue) {
           jsonApiRecord.relationships = jsonApiRecord.relationships || {}
@@ -415,8 +420,8 @@ export const buildJsonApiResponse = async (scope, records, included = [], isSing
           }
 
           relationshipObject.links = {
-            self: buildRelationshipUrl(context, scope, scopeName, record[idField], relName, true),
-            related: buildRelationshipUrl(context, scope, scopeName, record[idField], relName, false)
+            self: buildRelationshipUrl(context, scope, scopeName, resourceId, relName, true),
+            related: buildRelationshipUrl(context, scope, scopeName, resourceId, relName, false)
           }
 
           jsonApiRecord.relationships[relName] = relationshipObject
@@ -427,8 +432,8 @@ export const buildJsonApiResponse = async (scope, records, included = [], isSing
           }
 
           relationshipObject.links = {
-            self: buildRelationshipUrl(context, scope, scopeName, record[idField], relName, true),
-            related: buildRelationshipUrl(context, scope, scopeName, record[idField], relName, false)
+            self: buildRelationshipUrl(context, scope, scopeName, resourceId, relName, true),
+            related: buildRelationshipUrl(context, scope, scopeName, resourceId, relName, false)
           }
 
           jsonApiRecord.relationships[relName] = relationshipObject