json-rest-api 1.0.24 → 1.0.26

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/query/anyapi-query-adapter.js

@@ -71,14 +71,6 @@ const SELECT_METHODS = new Set(['select', 'columns', 'distinct'])
 
 const AGGREGATE_METHODS = new Set(['count', 'min', 'max', 'sum', 'avg'])
 
-const CALLBACK_FIRST_METHODS = new Set([
-  'where',
-  'andWhere',
-  'orWhere',
-  'having',
-  'orHaving',
-])
-
 const isFunction = (value) => typeof value === 'function'
 const isObject = (value) => value && typeof value === 'object' && !Array.isArray(value)
 
@@ -149,13 +141,6 @@ const translateJoinObject = (adapter, obj) => {
   return result
 }
 
-const maybeWrapCallback = (adapter, callback) => {
-  if (!isFunction(callback)) return callback
-  return function wrappedCallback (...args) {
-    return callback.apply(adapter.proxy, args)
-  }
-}
-
 const isRaw = (value) => Boolean(value && typeof value === 'object' && typeof value.toSQL === 'function' && value.toSQL().method)
 
 const ensureArray = (value) => (Array.isArray(value) ? value : [value])
@@ -317,12 +302,39 @@ export class AnyapiQueryAdapter {
     this.aliasActualNames.set(alias, alias)
   }
 
-  #translateWhereArgs (method, args) {
+  #wrapQueryCallback (callback) {
+    if (!isFunction(callback)) return callback
+    const adapter = this
+
+    return function wrappedCallback (...args) {
+      const callbackTarget = this
+      const callbackProxy = adapter.#createProxy(callbackTarget)
+      const callbackArgs = args.map((arg) => arg === callbackTarget ? callbackProxy : arg)
+      return callback.apply(callbackProxy, callbackArgs)
+    }
+  }
+
+  #wrapJoinCallback (callback) {
+    if (!isFunction(callback)) return callback
+    const adapter = this
+
+    return function wrappedCallback (...args) {
+      const callbackTarget = this
+      const callbackProxy = adapter.#createJoinProxy(callbackTarget)
+      const callbackArgs = args.map((arg) => arg === callbackTarget ? callbackProxy : arg)
+      return callback.apply(callbackProxy, callbackArgs)
+    }
+  }
+
+  #translateWhereArgs (args, { joinClause = false } = {}) {
     if (args.length === 0) return args
     const [first, ...rest] = args
 
     if (isFunction(first)) {
-      return [maybeWrapCallback(this, first), ...rest]
+      const wrappedGroup = joinClause
+        ? this.#wrapJoinCallback(first)
+        : this.#wrapQueryCallback(first)
+      return [wrappedGroup, ...rest]
     }
 
     if (isObject(first) && !isRaw(first)) {
@@ -337,7 +349,7 @@ export class AnyapiQueryAdapter {
 
     if (rest.length > 0 && isFunction(rest[rest.length - 1])) {
       const newRest = [...rest]
-      newRest[newRest.length - 1] = maybeWrapCallback(this, rest[rest.length - 1])
+      newRest[newRest.length - 1] = this.#wrapQueryCallback(rest[rest.length - 1])
       return [translatedFirst, ...newRest]
     }
 
@@ -350,7 +362,7 @@ export class AnyapiQueryAdapter {
     const translatedColumn = this.translateColumn(column)
 
     if (isFunction(values)) {
-      return [translatedColumn, maybeWrapCallback(this, values), ...rest]
+      return [translatedColumn, this.#wrapQueryCallback(values), ...rest]
     }
 
     return [translatedColumn, values, ...rest]
@@ -439,7 +451,7 @@ export class AnyapiQueryAdapter {
     const [first, ...rest] = args
 
     if (isFunction(first)) {
-      return [maybeWrapCallback(this, first), ...rest]
+      return [this.#wrapJoinCallback(first), ...rest]
     }
 
     if (isObject(first) && !isRaw(first)) {
@@ -454,7 +466,7 @@ export class AnyapiQueryAdapter {
 
     const translatedRest = rest.map((value, index) => {
       if (isFunction(value)) {
-        return maybeWrapCallback(this, value)
+        return this.#wrapJoinCallback(value)
       }
       if (typeof value !== 'string') {
         return value
@@ -475,7 +487,7 @@ export class AnyapiQueryAdapter {
     const translatedColumn = typeof column === 'string' ? this.translateColumn(column) : column
 
     if (isFunction(values)) {
-      return [translatedColumn, maybeWrapCallback(this, values), ...rest]
+      return [translatedColumn, this.#wrapQueryCallback(values), ...rest]
     }
 
     return [translatedColumn, values, ...rest]
@@ -510,7 +522,7 @@ export class AnyapiQueryAdapter {
           let translatedArgs = args
 
           if (WHERE_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateWhereArgs(prop, args)
+            translatedArgs = adapter.#translateWhereArgs(args, { joinClause: true })
           } else if (WHERE_IN_METHODS.has(prop)) {
             translatedArgs = adapter.#translateWhereInArgs(args)
           } else if (BETWEEN_METHODS.has(prop)) {
@@ -607,7 +619,7 @@ export class AnyapiQueryAdapter {
           let translatedArgs = args
 
           if (WHERE_METHODS.has(prop)) {
-            translatedArgs = adapter.#translateWhereArgs(prop, args)
+            translatedArgs = adapter.#translateWhereArgs(args)
           } else if (WHERE_IN_METHODS.has(prop)) {
             translatedArgs = adapter.#translateWhereInArgs(args)
           } else if (BETWEEN_METHODS.has(prop)) {
@@ -630,8 +642,6 @@ export class AnyapiQueryAdapter {
             translatedArgs = adapter.#translateSelectArgs(args)
           } else if (AGGREGATE_METHODS.has(prop)) {
             translatedArgs = adapter.#translateAggregateArgs(args)
-          } else if (CALLBACK_FIRST_METHODS.has(prop) && args.length && isFunction(args[0])) {
-            translatedArgs = [maybeWrapCallback(adapter, args[0]), ...args.slice(1)]
           }
 
           const result = value.apply(target, translatedArgs)

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
 }