json-rest-api 1.0.13 → 1.0.15

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

@@ -1,9 +1,9 @@
-import { RestApiResourceError } from '../../../lib/rest-api-errors.js';
-import { validateGetPayload } 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 { RestApiResourceError } from '../../../lib/rest-api-errors.js'
+import { validateGetPayload } 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'
 
 /**
  * GET
@@ -14,171 +14,171 @@ import { cascadeConfig } from './common.js';
  * @param {object} [queryParams.fields] - An object to request only specific fields (sparse fieldsets). Keys are resource types, values are comma-separated field names.
  * @returns {Promise<object>} A Promise that resolves to the JSON:API response document.
  */
-export default async function getMethod({ 
-  params, 
-  context, 
-  vars, 
-  helpers, 
-  scope, 
-  scopes, 
-  runHooks, 
-  apiOptions, 
-  pluginOptions, 
-  scopeOptions, 
+export default async function getMethod ({
+  params,
+  context,
+  vars,
+  helpers,
+  scope,
+  scopes,
+  runHooks,
+  apiOptions,
+  pluginOptions,
+  scopeOptions,
   scopeName,
   api
 }) {
-  context.method = 'get';
+  context.method = 'get'
 
   // 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;
-  context.queryParams = params.queryParams || {};
+  context.schemaInfo = scopes[scopeName].vars.schemaInfo
+  context.queryParams = params.queryParams || {}
 
   // These only make sense as parameter per query
-  context.queryParams.fields = cascadeConfig('fields', [context.queryParams], {});
-  context.queryParams.include = cascadeConfig('include', [context.queryParams], []);
-  
-  context.transaction = params.transaction;
-  context.db = context.transaction || api.knex.instance;
+  context.queryParams.fields = cascadeConfig('fields', [context.queryParams], {})
+  context.queryParams.include = cascadeConfig('include', [context.queryParams], [])
 
-  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 schemaStructure = context.schemaInfo.schemaInstance.structure;
-  const schemaRelationships = context.schemaInfo.schemaRelationships;
+  const schemaStructure = context.schemaInfo.schemaInstance.structure
+  const schemaRelationships = context.schemaInfo.schemaRelationships
 
-  context.id = params.id;
+  context.id = params.id
 
   // Validate GET request to ensure required parameters are present and properly formatted.
   // This checks that 'id' parameter exists and is not empty (you can't GET without an ID),
   // validates 'include' contains valid relationship names (not arbitrary fields), and ensures
   // 'fields' for sparse fieldsets follow the format fields[type]=comma,separated,list.
   // Example: validates id: '123' exists, include: ['author', 'tags'] are real relationships.
-  validateGetPayload({ id: context.id, queryParams: context.queryParams }, vars.includeDepthLimit);
+  validateGetPayload({ id: context.id, queryParams: context.queryParams }, vars.includeDepthLimit)
 
   // Fetch minimal record for authorization checks
   const minimalRecord = await helpers.dataGetMinimal({
     scopeName,
     context,
     runHooks
-  });
+  })
 
   if (!minimalRecord) {
     throw new RestApiResourceError(
-      `Resource not found`,
-      { 
+      'Resource not found',
+      {
         subtype: 'not_found',
         resourceType: scopeName,
         resourceId: context.id
       }
-    );
+    )
   }
 
-  context.minimalRecord = minimalRecord;
+  context.minimalRecord = minimalRecord
 
   // Centralised checkPermissions function
   await scope.checkPermissions({
     method: 'get',
     originalContext: context,
-  });
-  
-  await runHooks('beforeData');
-  await runHooks('beforeDataGet');
+  })
+
+  await runHooks('beforeData')
+  await runHooks('beforeDataGet')
 
   context.record = await helpers.dataGet({
     scopeName,
     context,
     runHooks
-  });
+  })
 
   // Check if record was found - storage layer returns null/undefined for non-existent records.
   // This generates a proper 404 error with JSON:API error format instead of returning empty data.
   if (!context.record || !context.record.data) {
     throw new RestApiResourceError(
-      `Resource not found`,
-      { 
+      'Resource not found',
+      {
         subtype: 'not_found',
         resourceType: scopeName,
         resourceId: context.id
       }
-    );
+    )
   }
 
   // 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)
+
+  await runHooks('checkDataPermissions')
+  await runHooks('checkDataPermissionsGet')
 
-  await runHooks('checkDataPermissions');
-  await runHooks('checkDataPermissionsGet');
-  
   // Make a backup
-  context.originalRecord = structuredClone(context.record);
+  context.originalRecord = structuredClone(context.record)
 
   // 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)
+
   // Enrich attributes for the main resource
   // Pass computedDependencies from context (set by dataGet in Knex plugin)
   // This tells enrichAttributes which fields to remove after computation
-  context.record.data.attributes = await scope.enrichAttributes({ 
-    attributes: context.record.data.attributes, 
+  context.record.data.attributes = await scope.enrichAttributes({
+    attributes: context.record.data.attributes,
     parentContext: context,
-    requestedComputedFields: requestedComputedFields,
+    requestedComputedFields,
     isMainResource: true,
     computedDependencies: context.computedDependencies  // Fields to remove if not requested
-  });
-  
+  })
+
   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$__
-    });
+    })
   }
-  
-  await runHooks('enrichRecordWithRelationships');
+
+  await runHooks('enrichRecordWithRelationships')
 
   // The called hooks should NOT change context.record
-  await runHooks('finish');
-  await runHooks('finishGet');
-  
+  await runHooks('finish')
+  await runHooks('finishGet')
+
   // Get schema info for transformation
-  context.schemaInfo = scopes[scopeName].vars.schemaInfo;
-  
+  context.schemaInfo = scopes[scopeName].vars.schemaInfo
+
   // 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/patch-relationship.js

@@ -2,27 +2,27 @@
  * PATCH RELATIONSHIP
  * Completely replaces a relationship
  * PATCH /api/articles/1/relationships/author
- * 
+ *
  * @param {string} id - The ID of the resource
  * @param {string} relationshipName - The name of the relationship
  * @param {object|array} relationshipData - New relationship data
  * @returns {Promise<void>} 204 No Content
  */
 export default async function patchRelationshipMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeName, api }) {
-  context.method = 'patchRelationship';
-  context.id = params.id;
-  context.relationshipName = params.relationshipName;
+  context.method = 'patchRelationship'
+  context.id = params.id
+  context.relationshipName = params.relationshipName
 
   // Transaction handling
-  context.transaction = params.transaction || 
-    (helpers.newTransaction && !params.transaction ? await helpers.newTransaction() : null);
-  context.shouldCommit = !params.transaction && !!context.transaction;
+  context.transaction = params.transaction ||
+    (helpers.newTransaction && !params.transaction ? await helpers.newTransaction() : null)
+  context.shouldCommit = !params.transaction && !!context.transaction
   context.db = context.transaction || api.knex.instance
 
   try {
     // Check permissions
-    await runHooks('checkPermissions');
-    await runHooks('checkPermissionsPatchRelationship');
+    await runHooks('checkPermissions')
+    await runHooks('checkPermissionsPatchRelationship')
 
     // Reuse existing patch with relationship data
     await scope.patch({
@@ -39,18 +39,17 @@ export default async function patchRelationshipMethod ({ params, context, vars,
       transaction: context.transaction,
       simplified: false,
       isTransport: params.isTransport
-    });
+    })
 
-    await runHooks('finish');
-    await runHooks('finishPatchRelationship');
+    await runHooks('finish')
+    await runHooks('finishPatchRelationship')
 
     if (context.shouldCommit) {
-      await context.transaction.commit();
+      await context.transaction.commit()
     }
 
-    return; // 204 No Content
-
+    // 204 No Content
   } catch (error) {
-    await handleWriteMethodError(error, context, 'PATCH_RELATIONSHIP', scopeName, log);
+    await handleWriteMethodError(error, context, 'PATCH_RELATIONSHIP', scopeName, log)
   }
-}
+}

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

@@ -1,17 +1,17 @@
-import { RestApiResourceError } from '../../../lib/rest-api-errors.js';
-import { validatePatchPayload } from '../lib/querying-writing/payload-validators.js';
-import { processRelationships } from '../lib/writing/relationship-processor.js';
-import { updateManyToManyRelationship } 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 { validatePatchPayload } from '../lib/querying-writing/payload-validators.js'
+import { processRelationships } from '../lib/writing/relationship-processor.js'
+import { updateManyToManyRelationship } 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'
 
 /**
  * PATCH
@@ -21,39 +21,39 @@ import {
  * For relationships, only the ones explicitly provided will be updated.
  * Just like PUT, it CANNOT have the `included` array in data.
  */
-export default async function patchMethod({ 
-  params, 
-  context, 
-  vars, 
-  helpers, 
-  scope, 
-  scopes, 
-  runHooks, 
-  apiOptions, 
-  pluginOptions, 
-  scopeOptions, 
+export default async function patchMethod ({
+  params,
+  context,
+  vars,
+  helpers,
+  scope,
+  scopes,
+  runHooks,
+  apiOptions,
+  pluginOptions,
+  scopeOptions,
   scopeName,
   api,
   log
 }) {
-  context.method = 'patch';
-    
+  context.method = 'patch'
+
   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('beforeProcessingPatch');
+    await runHooks('beforeProcessing')
+    await runHooks('beforeProcessingPatch')
 
     // Validate PATCH payload to ensure the partial update actually contains changes.
     // PATCH requests must include either attributes to update or relationships to modify -
@@ -61,11 +61,11 @@ export default async function patchMethod({
     // are explicit about what they want to change. Unlike PUT, PATCH preserves all fields
     // not mentioned in the request.
     // Example: data must have either attributes: {title: 'New'} or relationships: {author: {...}}
-    validatePatchPayload(context.inputRecord, scopes);
-    
+    validatePatchPayload(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
@@ -73,48 +73,48 @@ export default async function patchMethod({
     const { belongsToUpdates, manyToManyRelationships } = processRelationships(
       scope,
       { context }
-    );
+    )
 
-    await validateResourceAttributesBeforeWrite({ 
-      context, 
-      schema, 
-      belongsToUpdates, 
+    await validateResourceAttributesBeforeWrite({
+      context,
+      schema,
+      belongsToUpdates,
       runHooks,
-      isPartialValidation: true 
-    });
+      isPartialValidation: true
+    })
 
     // Fetch minimal record for authorization checks
     const minimalRecord = await helpers.dataGetMinimal({
       scopeName,
       context,
       runHooks
-    });
+    })
 
     if (!minimalRecord) {
       throw new RestApiResourceError(
         `Resource not found: ${scopeName}/${context.id}`,
         ERROR_SUBTYPES.NOT_FOUND
-      );
+      )
     }
 
-    context.minimalRecord = minimalRecord;
+    context.minimalRecord = minimalRecord
 
     // Centralised checkPermissions function
     await scope.checkPermissions({
       method: 'patch',
       originalContext: context,
-    });
+    })
 
     // Merge belongsTo updates into attributes before patching the record
     if (Object.keys(belongsToUpdates).length > 0) {
       context.inputRecord.data.attributes = {
         ...context.inputRecord.data.attributes,
         ...belongsToUpdates
-      };
+      }
     }
 
-    await runHooks('beforeDataCall');
-    await runHooks('beforeDataCallPatch');
+    await runHooks('beforeDataCall')
+    await runHooks('beforeDataCallPatch')
 
     // Apply field setters after validation and before storage
     if (context.inputRecord?.data?.attributes) {
@@ -124,17 +124,17 @@ export default async function patchMethod({
         context,
         api,
         helpers
-      );
+      )
     }
 
     // Call the storage helper - should return the patched record
     await helpers.dataPatch({
       scopeName,
       context
-    });
+    })
 
-    await runHooks('afterDataCallPatch');
-    await runHooks('afterDataCall');
+    await runHooks('afterDataCallPatch')
+    await runHooks('afterDataCall')
 
     // Process many-to-many relationships after main record update
     // For PATCH, we only update the relationships that were explicitly provided
@@ -147,11 +147,11 @@ export default async function patchMethod({
           relDef,
           relData,
           isUpdate: true,
-        });
-        continue;
+        })
+        continue
       }
 
-      validatePivotResource(scopes, relDef, relName);
+      validatePivotResource(scopes, relDef, relName)
 
       await updateManyToManyRelationship(null, {
         api,
@@ -161,9 +161,9 @@ export default async function patchMethod({
           relData,
           transaction: context.transaction
         }
-      });
+      })
     }
-    
+
     const ret = await handleRecordReturnAfterWrite({
       context,
       scopeName,
@@ -176,17 +176,16 @@ export default async function patchMethod({
       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, 'PATCH', scopeName, log, runHooks);
+    await handleWriteMethodError(error, context, 'PATCH', scopeName, log, runHooks)
   }
 }