json-rest-api 1.0.14 → 1.0.15

package/plugins/core/rest-api-plugin-methods/put.js

@@ -1,17 +1,17 @@
-import { RestApiResourceError } from '../../../lib/rest-api-errors.js';
-import { validatePutPayload } from '../lib/querying-writing/payload-validators.js';
-import { processRelationships } from '../lib/writing/relationship-processor.js';
-import { updateManyToManyRelationship, createPivotRecords } from '../lib/writing/many-to-many-manipulations.js';
-import { ERROR_SUBTYPES } from '../lib/querying-writing/knex-constants.js';
-import { 
-  setupCommonRequest, 
+import { RestApiResourceError } from '../../../lib/rest-api-errors.js'
+import { validatePutPayload } from '../lib/querying-writing/payload-validators.js'
+import { processRelationships } from '../lib/writing/relationship-processor.js'
+import { updateManyToManyRelationship, createPivotRecords } from '../lib/writing/many-to-many-manipulations.js'
+import { ERROR_SUBTYPES } from '../lib/querying-writing/knex-constants.js'
+import {
+  setupCommonRequest,
   validateResourceAttributesBeforeWrite,
   validateRelationshipAccess,
   applyFieldSetters,
   validatePivotResource,
   handleRecordReturnAfterWrite,
   handleWriteMethodError
-} from './common.js';
+} from './common.js'
 
 /**
  * PUT
@@ -20,39 +20,39 @@ import {
  * PUT is a complete replacement - any relationships not provided will be removed/nulled.
  * This method does NOT support creating new related resources via an `included` array.
  */
-export default async function putMethod({ 
-  params, 
-  context, 
-  vars, 
-  helpers, 
-  scope, 
-  scopes, 
-  runHooks, 
-  apiOptions, 
-  pluginOptions, 
-  scopeOptions, 
+export default async function putMethod ({
+  params,
+  context,
+  vars,
+  helpers,
+  scope,
+  scopes,
+  runHooks,
+  apiOptions,
+  pluginOptions,
+  scopeOptions,
   scopeName,
   api,
   log
 }) {
-  context.method = 'put';
-  
+  context.method = 'put'
+
   try {
     const { schema, schemaStructure, schemaRelationships } = await setupCommonRequest({
-      params, 
-      context, 
-      vars, 
-      scopes, 
-      scopeOptions, 
+      params,
+      context,
+      vars,
+      scopes,
+      scopeOptions,
       scopeName,
-      api, 
+      api,
       helpers
-    });
-    context.id = context.inputRecord.data.id;
-    
+    })
+    context.id = context.inputRecord.data.id
+
     // Run early hooks for pre-processing (e.g., file handling)
-    await runHooks('beforeProcessing');
-    await runHooks('beforeProcessingPut');
+    await runHooks('beforeProcessing')
+    await runHooks('beforeProcessingPut')
 
     // Validate PUT payload to ensure it's a complete resource replacement operation.
     // PUT requires the full resource representation including ID (unlike POST which generates ID).
@@ -60,35 +60,35 @@ export default async function putMethod({
     // read-only), and ensures the payload represents a complete replacement. Any fields not
     // provided will be removed or reset to defaults - this is the key difference from PATCH.
     // Example: PUT to /articles/123 must have data.id: '123' and all required fields.
-    validatePutPayload(context.inputRecord, scopes);
-    
+    validatePutPayload(context.inputRecord, scopes)
+
     // Validate that user has read access to all related resources
     // This ensures users can only create relationships to resources they can access
-    await validateRelationshipAccess(context, context.inputRecord, helpers, runHooks, api);
-    
+    await validateRelationshipAccess(context, context.inputRecord, helpers, runHooks, api)
+
     // Extract foreign keys from JSON:API relationships and prepare many-to-many operations
     // Example: relationships.author -> author_id: '123' for storage
     // Example: relationships.tags -> array of pivot records to create later
     const { belongsToUpdates, manyToManyRelationships } = processRelationships(
       scope,
       { context }
-    );
+    )
 
-    await validateResourceAttributesBeforeWrite({ 
-      context, 
-      schema, 
-      belongsToUpdates, 
+    await validateResourceAttributesBeforeWrite({
+      context,
+      schema,
+      belongsToUpdates,
       runHooks
-    });
+    })
 
     // Check existence first
     context.exists = await helpers.dataExists({
       scopeName,
       context
-    });
-  
-    context.isCreate = !context.exists;
-    context.isUpdate = context.exists;
+    })
+
+    context.isCreate = !context.exists
+    context.isUpdate = context.exists
 
     // Fetch minimal record for authorization checks (only for updates)
     if (context.isUpdate) {
@@ -96,64 +96,64 @@ export default async function putMethod({
         scopeName,
         context,
         runHooks
-      });
+      })
 
       if (!minimalRecord) {
         throw new RestApiResourceError(
           `Resource not found: ${scopeName}/${context.id}`,
           ERROR_SUBTYPES.NOT_FOUND
-        );
+        )
       }
 
-      context.minimalRecord = minimalRecord;
+      context.minimalRecord = minimalRecord
     }
 
     // For PUT, we also need to handle relationships that are NOT provided
     // (they should be set to null/empty as PUT is a complete replacement)
-    const allRelationships = {};
-    
+    const allRelationships = {}
+
     // Collect all defined relationships for this resource
     for (const [relName, relDef] of Object.entries(schemaRelationships || {})) {
       if (relDef.type === 'manyToMany') {
-        allRelationships[relName] = { 
-          type: 'manyToMany', 
+        allRelationships[relName] = {
+          type: 'manyToMany',
           relDef: {
             through: relDef.through,
             foreignKey: relDef.foreignKey,
             otherKey: relDef.otherKey
           }
-        };
+        }
       }
     }
-    
+
     // Also check schema fields for belongsTo relationships
     for (const [fieldName, fieldDef] of Object.entries(schemaStructure)) {
       if (fieldDef.as && fieldDef.belongsTo) {
-        allRelationships[fieldDef.as] = { 
+        allRelationships[fieldDef.as] = {
           type: 'belongsTo',
           fieldName,
-          fieldDef 
-        };
+          fieldDef
+        }
       }
     }
-    
+
     // Process missing relationships (PUT should null them out only if relationships object exists)
-    const hasRelationshipsObject = context.inputRecord.data.relationships !== undefined;
-    const providedRelationships = new Set(Object.keys(context.inputRecord.data.relationships || {}));
-    
+    const hasRelationshipsObject = context.inputRecord.data.relationships !== undefined
+    const providedRelationships = new Set(Object.keys(context.inputRecord.data.relationships || {}))
+
     // Only null out missing relationships if a relationships object was provided
     if (hasRelationshipsObject) {
       for (const [relName, relInfo] of Object.entries(allRelationships)) {
         if (!providedRelationships.has(relName)) {
           if (relInfo.type === 'belongsTo') {
-            belongsToUpdates[relInfo.fieldName] = null;
+            belongsToUpdates[relInfo.fieldName] = null
           } else if (relInfo.type === 'manyToMany') {
             // Add to manyToManyRelationships with empty array
             manyToManyRelationships.push({
               relName,
               relDef: relInfo.relDef,
               relData: []  // Empty array means delete all
-            });
+            })
           }
         }
       }
@@ -164,18 +164,18 @@ export default async function putMethod({
       context.inputRecord.data.attributes = {
         ...context.inputRecord.data.attributes,
         ...belongsToUpdates
-      };
+      }
     }
 
     // Centralised checkPermissions function
     await scope.checkPermissions({
       method: 'put',
       originalContext: context,
-    });
-  
-    await runHooks('beforeDataCall');
-    await runHooks('beforeDataCallPut');
-    
+    })
+
+    await runHooks('beforeDataCall')
+    await runHooks('beforeDataCallPut')
+
     // Apply field setters after validation and before storage
     if (context.inputRecord?.data?.attributes) {
       context.inputRecord.data.attributes = await applyFieldSetters(
@@ -184,16 +184,16 @@ export default async function putMethod({
         context,
         api,
         helpers
-      );
+      )
     }
-    
+
     // Pass the operation type to the helper
     await helpers.dataPut({
       scopeName,
       context
-    });
-    await runHooks('afterDataCallPut');
-    await runHooks('afterDataCall');
+    })
+    await runHooks('afterDataCallPut')
+    await runHooks('afterDataCall')
 
     // Process many-to-many relationships after main record update/creation
     for (const { relName, relDef, relData } of manyToManyRelationships) {
@@ -205,11 +205,11 @@ export default async function putMethod({
           relDef,
           relData,
           isUpdate: context.isUpdate,
-        });
-        continue;
+        })
+        continue
       }
 
-      await validatePivotResource(scopes, relDef, relName);
+      await validatePivotResource(scopes, relDef, relName)
 
       if (context.isUpdate) {
         await updateManyToManyRelationship(null, {
@@ -220,12 +220,12 @@ export default async function putMethod({
             relData,
             transaction: context.transaction
           }
-        });
+        })
       } else if (relData.length > 0) {
-        await createPivotRecords(api, context.id, relDef, relData, context.transaction);
+        await createPivotRecords(api, context.id, relDef, relData, context.transaction)
       }
     }
-   
+
     const ret = await handleRecordReturnAfterWrite({
       context,
       scopeName,
@@ -238,17 +238,16 @@ export default async function putMethod({
       runHooks,
       helpers,
       log
-    });
+    })
 
     // Commit transaction if we created it
     if (context.shouldCommit) {
-      await context.transaction.commit();
-      await runHooks('afterCommit');
+      await context.transaction.commit()
+      await runHooks('afterCommit')
     }
 
-    return ret;
-   
+    return ret
   } catch (error) {
-    await handleWriteMethodError(error, context, 'PUT', scopeName, log, runHooks);
+    await handleWriteMethodError(error, context, 'PUT', scopeName, log, runHooks)
   }
 }

package/plugins/core/rest-api-plugin-methods/query.js

@@ -1,9 +1,9 @@
-import { RestApiValidationError } from '../../../lib/rest-api-errors.js';
-import { validateQueryPayload } from '../lib/querying-writing/payload-validators.js';
-import { normalizeRecordAttributes } from '../lib/querying-writing/database-value-normalizers.js';
-import { getRequestedComputedFields } from '../lib/querying-writing/knex-field-helpers.js';
-import { transformJsonApiToSimplified } from '../lib/querying-writing/simplified-helpers.js';
-import { cascadeConfig } from './common.js';
+import { RestApiValidationError } from '../../../lib/rest-api-errors.js'
+import { validateQueryPayload } from '../lib/querying-writing/payload-validators.js'
+import { normalizeRecordAttributes } from '../lib/querying-writing/database-value-normalizers.js'
+import { getRequestedComputedFields } from '../lib/querying-writing/knex-field-helpers.js'
+import { transformJsonApiToSimplified } from '../lib/querying-writing/simplified-helpers.js'
+import { cascadeConfig } from './common.js'
 
 /**
  * QUERY
@@ -19,57 +19,57 @@ import { cascadeConfig } from './common.js';
  * @param {object} [queryParams.page] - An object for pagination. Typically includes `number` (page number) and `size` (items per page). E.g., `{ number: 1, size: 10 }`.
  * @returns {Promise<object>} A Promise that resolves to the JSON:API response document containing the resource collection.
  */
-export default async function queryMethod({ 
-  params, 
-  context, 
-  vars, 
-  helpers, 
-  scope, 
-  scopes, 
-  runHooks, 
-  apiOptions, 
-  pluginOptions, 
-  scopeOptions, 
-  scopeName, 
+export default async function queryMethod ({
+  params,
+  context,
+  vars,
+  helpers,
+  scope,
+  scopes,
+  runHooks,
+  apiOptions,
+  pluginOptions,
+  scopeOptions,
+  scopeName,
   log,
-  api 
+  api
 }) {
-  context.method = 'query';
-  
+  context.method = 'query'
+
   // Determine which simplified setting to use based on transport
-  const isTransport = params.isTransport === true;
-  
+  const isTransport = params.isTransport === true
+
   // Use vars which automatically cascade from scope to global
-  const defaultSimplified = isTransport ? vars.simplifiedTransport : vars.simplifiedApi;
-  
+  const defaultSimplified = isTransport ? vars.simplifiedTransport : vars.simplifiedApi
+
   // Get simplified setting - from params only (per-call override) or use default
-  context.simplified = params.simplified !== undefined ? params.simplified : defaultSimplified;
+  context.simplified = params.simplified !== undefined ? params.simplified : defaultSimplified
 
   // Assign common context properties
-  context.schemaInfo = scopes[scopeName].vars.schemaInfo; // This is the object variable created by compileSchemas
-  context.queryParams = params.queryParams || {};
+  context.schemaInfo = scopes[scopeName].vars.schemaInfo // This is the object variable created by compileSchemas
+  context.queryParams = params.queryParams || {}
 
   // These only make sense as parameter per query
-  context.queryParams.fields = cascadeConfig('fields', [params.queryParams], {});
-  context.queryParams.include = cascadeConfig('include', [params.queryParams], []);
-  context.queryParams.sort = cascadeConfig('sort', [params.queryParams], []);
-  context.queryParams.page = cascadeConfig('page', [params.queryParams], {});
+  context.queryParams.fields = cascadeConfig('fields', [params.queryParams], {})
+  context.queryParams.include = cascadeConfig('include', [params.queryParams], [])
+  context.queryParams.sort = cascadeConfig('sort', [params.queryParams], [])
+  context.queryParams.page = cascadeConfig('page', [params.queryParams], {})
 
-  context.transaction = params.transaction;
-  context.db = context.transaction || api.knex.instance;
-  
-  context.scopeName = scopeName;
+  context.transaction = params.transaction
+  context.db = context.transaction || api.knex.instance
+
+  context.scopeName = scopeName
 
   // These are just shortcuts used in this function and will be returned
-  const searchSchema = context.schemaInfo.searchSchemaInstance;
-  const schemaStructure = context.schemaInfo.schemaInstance.structure;
-  const schemaRelationships = context.schemaInfo.schemaRelationships;
+  const searchSchema = context.schemaInfo.searchSchemaInstance
+  const schemaStructure = context.schemaInfo.schemaInstance.structure
+  const schemaRelationships = context.schemaInfo.schemaRelationships
 
   // Sortable fields and sort (mab)
-  context.sortableFields = vars.sortableFields;
+  context.sortableFields = vars.sortableFields
   // Apply default sort if no sort specified
   if (context.queryParams.sort.length === 0 && vars.defaultSort) {
-    context.queryParams.sort = Array.isArray(vars.defaultSort) ? vars.defaultSort : [vars.defaultSort];
+    context.queryParams.sort = Array.isArray(vars.defaultSort) ? vars.defaultSort : [vars.defaultSort]
   }
 
   // Validate query parameters to ensure they follow JSON:API specification and security rules.
@@ -77,7 +77,7 @@ export default async function queryMethod({
   // (preventing SQL injection), pagination uses valid page[size]/page[number] format, and include
   // paths reference real relationships. Example: sort: ['-createdAt', 'title'] is checked against
   // sortableFields to ensure users can't sort by sensitive fields like 'password_hash'.
-  validateQueryPayload({ queryParams: context.queryParams }, context.sortableFields, vars.includeDepthLimit);
+  validateQueryPayload({ queryParams: context.queryParams }, context.sortableFields, vars.includeDepthLimit)
 
   // Validate search/filter parameters against searchSchema
   if (context.queryParams.filters && Object.keys(context.queryParams.filters).length > 0) {
@@ -85,7 +85,7 @@ export default async function queryMethod({
     if (!searchSchema) {
       throw new RestApiValidationError(
         `Filtering is not enabled for resource '${scopeName}'. To enable filtering, add 'search: true' to schema fields or define a searchSchema.`,
-        { 
+        {
           fields: Object.keys(context.queryParams.filters).map(field => `filters.${field}`),
           violations: [{
             field: 'filters',
@@ -93,13 +93,13 @@ export default async function queryMethod({
             message: 'Resource does not have searchable fields defined'
           }]
         }
-      );
+      )
     }
-  
+
     // Validate the filter parameters searchSchema
-    const { validatedObject, errors } = await searchSchema.validate(context.queryParams.filters, { 
+    const { validatedObject, errors } = await searchSchema.validate(context.queryParams.filters, {
       onlyObjectValues: true // Partial validation for filters
-    });
+    })
 
     // If there are validation errors, throw an error
     if (Object.keys(errors).length > 0) {
@@ -107,101 +107,101 @@ export default async function queryMethod({
         field: `filters.${field}`,
         rule: error.code || 'invalid_value',
         message: error.message
-      }));
-      
+      }))
+
       throw new RestApiValidationError(
         'Invalid filter parameters',
-        { 
+        {
           fields: Object.keys(errors).map(field => `filters.${field}`),
-          violations 
+          violations
         }
-      );
+      )
     }
-    
+
     // Replace filter with validated/transformed values
-    context.queryParams.filters = validatedObject;
+    context.queryParams.filters = validatedObject
   }
 
   // Centralised checkPermissions function
   await scope.checkPermissions({
     method: 'query',
     originalContext: context,
-  });
+  })
 
-  await runHooks('beforeData');
-  await runHooks('beforeDataQuery');
+  await runHooks('beforeData')
+  await runHooks('beforeDataQuery')
   context.record = await helpers.dataQuery({
     scopeName,
     context,
     runHooks
-  });
+  })
 
   // Normalize database values (e.g., convert 1/0 to true/false for booleans)
-  context.record = normalizeRecordAttributes(context.record, scopes);
+  context.record = normalizeRecordAttributes(context.record, scopes)
 
   // Make a backup
   try {
-    context.originalRecord = structuredClone(context.record);
+    context.originalRecord = structuredClone(context.record)
   } catch (e) {
     log.error('Failed to clone record:', {
       error: e.message,
       recordKeys: Object.keys(context.record || {}),
       hasHttpRequest: !!context.raw?.req
-    });
-    throw e;
+    })
+    throw e
   }
 
   // This will enhance record, which is the WHOLE JSON:API record
-  await runHooks('enrichRecord');
+  await runHooks('enrichRecord')
 
   // Get computed field information for main resource
-  const computedFields = scope.vars.schemaInfo?.computed || {};
-  const requestedFields = context.queryParams.fields?.[scopeName];
-  const requestedComputedFields = getRequestedComputedFields(scopeName, requestedFields, computedFields);
+  const computedFields = scope.vars.schemaInfo?.computed || {}
+  const requestedFields = context.queryParams.fields?.[scopeName]
+  const requestedComputedFields = getRequestedComputedFields(scopeName, requestedFields, computedFields)
 
   // Run enrichAttributes for every single set of attribute, calling it from the right scope
   for (const entry of context.record.data) {
-    entry.attributes = await scope.enrichAttributes({ 
-      attributes: entry.attributes, 
+    entry.attributes = await scope.enrichAttributes({
+      attributes: entry.attributes,
       parentContext: context,
-      requestedComputedFields: requestedComputedFields,
+      requestedComputedFields,
       isMainResource: true,
       computedDependencies: context.computedDependencies
-    });
+    })
   }
   for (const entry of (context.record.included || [])) {
-    const entryScope = scopes[entry.type];
-    const entryComputed = entryScope.vars.schemaInfo?.computed || {};
-    const entryRequestedFields = context.queryParams.fields?.[entry.type];
+    const entryScope = scopes[entry.type]
+    const entryComputed = entryScope.vars.schemaInfo?.computed || {}
+    const entryRequestedFields = context.queryParams.fields?.[entry.type]
     const entryRequestedComputed = getRequestedComputedFields(
-      entry.type, 
-      entryRequestedFields, 
+      entry.type,
+      entryRequestedFields,
       entryComputed
-    );
-    
-    entry.attributes = await entryScope.enrichAttributes({ 
-      attributes: entry.attributes, 
+    )
+
+    entry.attributes = await entryScope.enrichAttributes({
+      attributes: entry.attributes,
       parentContext: context,
       requestedComputedFields: entryRequestedComputed,
       isMainResource: false,
       computedDependencies: entry.__$jsonrestapi_computed_deps$__
-    });
+    })
   }
 
   // The called hooks should NOT change context.record
-  await runHooks('finish');
-  await runHooks('finishQuery');
-  
+  await runHooks('finish')
+  await runHooks('finishQuery')
+
   // Transform output if in simplified mode
   if (context.simplified) {
     // Convert JSON:API response back to simplified format
-    // Example: {data: {type: 'posts', id: '1', attributes: {title: 'My Post'}, relationships: {author: {data: {type: 'users', id: '123'}}}}} 
+    // Example: {data: {type: 'posts', id: '1', attributes: {title: 'My Post'}, relationships: {author: {data: {type: 'users', id: '123'}}}}}
     // becomes: {id: '1', title: 'My Post', author_id: '123'} - flattens structure and restores foreign keys
     return transformJsonApiToSimplified(
       { record: context.record },
       { context: { schemaStructure, schemaRelationships, scopes } }
-    );
+    )
   }
-  
-  return context.record;
-}
+
+  return context.record
+}

package/plugins/core/rest-api-plugin-methods/release.js

@@ -1,13 +1,12 @@
-import { ValidationError } from 'hooked-api';
+import { ValidationError } from 'hooked-api'
 
 /**
  * release
  * Runs the hook that tells plugins to release resources
  */
 export default async ({ runHooks }) => {
-
   // Run the addRoute hook to notify transport plugins
-  await runHooks('release');
-  
-  return { };
-}
+  await runHooks('release')
+
+  return { }
+}