json-rest-api 1.0.14 → 1.0.16

package/plugins/core/rest-api-plugin-methods/post-relationship.js

@@ -1,67 +1,67 @@
-import { RestApiResourceError, RestApiValidationError, RestApiPayloadError } from "../../../lib/rest-api-errors.js";
-import { findRelationshipDefinition, handleWriteMethodError } from "./common.js";
-import { createPivotRecords } from "../lib/writing/many-to-many-manipulations.js";
+import { RestApiResourceError, RestApiValidationError, RestApiPayloadError } from '../../../lib/rest-api-errors.js'
+import { findRelationshipDefinition, handleWriteMethodError } from './common.js'
+import { createPivotRecords } from '../lib/writing/many-to-many-manipulations.js'
 
 /**
    * POST RELATIONSHIP
    * Adds members to a to-many relationship
    * POST /api/articles/1/relationships/tags
-   * 
+   *
    * @param {string} id - The ID of the resource
    * @param {string} relationshipName - The name of the relationship
    * @param {array} relationshipData - Array of resource identifiers to add
    * @returns {Promise<void>} 204 No Content
-  */ 
- export default async function postRelationshipMethod({ params, context, vars, helpers, scope, scopes, runHooks, scopeName, api, log }) {
-  context.method = 'postRelationship';
-  context.id = params.id;
-  context.relationshipName = params.relationshipName;
-  context.schemaInfo = scopes[scopeName].vars.schemaInfo;
+  */
+export default async function postRelationshipMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeName, api, log }) {
+  context.method = 'postRelationship'
+  context.id = params.id
+  context.relationshipName = params.relationshipName
+  context.schemaInfo = scopes[scopeName].vars.schemaInfo
 
   // 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 {
   // Validate
-  const relDef = findRelationshipDefinition(context.schemaInfo, context.relationshipName);
-  if (!relDef) {
+    const relDef = findRelationshipDefinition(context.schemaInfo, context.relationshipName)
+    if (!relDef) {
       throw new RestApiResourceError(
       `Relationship '${context.relationshipName}' not found on resource '${scopeName}'`,
       { subtype: 'relationship_not_found' }
-      );
-  }
+      )
+    }
 
-  if (relDef.type !== 'hasMany' && relDef.type !== 'manyToMany') {
+    if (relDef.type !== 'hasMany' && relDef.type !== 'manyToMany') {
       throw new RestApiValidationError(
       `Cannot POST to to-one relationship '${context.relationshipName}'. Use PATCH instead.`,
       { fields: ['data'] }
-      );
-  }
+      )
+    }
 
-  if (!Array.isArray(params.relationshipData)) {
-      throw new RestApiPayloadError('POST to relationship requires array of resource identifiers');
-  }
+    if (!Array.isArray(params.relationshipData)) {
+      throw new RestApiPayloadError('POST to relationship requires array of resource identifiers')
+    }
 
-  // Check permissions
-  await runHooks('checkPermissions');
-  await runHooks('checkPermissionsPostRelationship');
+    // Check permissions
+    await runHooks('checkPermissions')
+    await runHooks('checkPermissionsPostRelationship')
 
-  // Verify parent exists
-  const exists = await helpers.dataExists({
+    // Verify parent exists
+    const exists = await helpers.dataExists({
       scopeName,
       context: { db: context.db, id: context.id, schemaInfo: context.schemaInfo },
-  });
+    })
 
-  if (!exists) {
-      throw new RestApiResourceError('Resource not found', { subtype: 'not_found' });
-  }
+    if (!exists) {
+      throw new RestApiResourceError('Resource not found', { subtype: 'not_found' })
+    }
 
-  // Add relationships
-  if (relDef?.through) {
+    // Add relationships
+    if (relDef?.through) {
       if (api.anyapi?.links?.attachMany) {
         await api.anyapi.links.attachMany({
           context,
@@ -69,43 +69,42 @@ import { createPivotRecords } from "../lib/writing/many-to-many-manipulations.js
           relName: context.relationshipName,
           relDef,
           relData: params.relationshipData,
-        });
+        })
       } else {
         await createPivotRecords(api, context.id, {
-            through: relDef.through,
-            foreignKey: relDef.foreignKey,
-            otherKey: relDef.otherKey
-        }, params.relationshipData, context.transaction);
+          through: relDef.through,
+          foreignKey: relDef.foreignKey,
+          otherKey: relDef.otherKey
+        }, params.relationshipData, context.transaction)
       }
-  } else if (relDef.type === 'hasMany') {
+    } else if (relDef.type === 'hasMany') {
       // Update foreign keys for hasMany
-      const targetType = relDef.target;
+      const targetType = relDef.target
       for (const identifier of params.relationshipData) {
-      await api.resources[targetType].patch({
+        await api.resources[targetType].patch({
           id: identifier.id,
           inputRecord: {
-          data: {
+            data: {
               type: targetType,
               id: identifier.id,
               attributes: { [relDef.foreignKey]: context.id }
-          }
+            }
           },
           transaction: context.transaction,
           simplified: false
-      });
+        })
       }
-  }
-
-  await runHooks('finish');
-  await runHooks('finishPostRelationship');
+    }
 
-  if (context.shouldCommit) {
-      await context.transaction.commit();
-  }
+    await runHooks('finish')
+    await runHooks('finishPostRelationship')
 
-  return; // 204 No Content
+    if (context.shouldCommit) {
+      await context.transaction.commit()
+    }
 
+    // 204 No Content
   } catch (error) {
-  await handleWriteMethodError(error, context, 'POST_RELATIONSHIP', scopeName, log, runHooks);
-}
+    await handleWriteMethodError(error, context, 'POST_RELATIONSHIP', scopeName, log, runHooks)
+  }
 };

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

@@ -1,15 +1,15 @@
-import { validatePostPayload } from '../lib/querying-writing/payload-validators.js';
-import { processRelationships } from '../lib/writing/relationship-processor.js';
-import { createPivotRecords } from '../lib/writing/many-to-many-manipulations.js';
-import { 
-  setupCommonRequest, 
+import { validatePostPayload } from '../lib/querying-writing/payload-validators.js'
+import { processRelationships } from '../lib/writing/relationship-processor.js'
+import { createPivotRecords } from '../lib/writing/many-to-many-manipulations.js'
+import {
+  setupCommonRequest,
   validateResourceAttributesBeforeWrite,
   validateRelationshipAccess,
   applyFieldSetters,
   validatePivotResource,
   handleRecordReturnAfterWrite,
   handleWriteMethodError
-} from './common.js';
+} from './common.js'
 
 /**
  * POST
@@ -17,92 +17,92 @@ import {
  * containing 'type' and 'attributes'. It can also establish relationships to existing resources.
  * The returned document contains the created resource with its server-assigned ID.
  */
-export default async function postMethod({ 
-  params, 
-  context, 
-  vars, 
-  helpers, 
-  scope, 
-  scopes, 
-  runHooks, 
-  apiOptions, 
-  pluginOptions, 
-  scopeOptions, 
+export default async function postMethod ({
+  params,
+  context,
+  vars,
+  helpers,
+  scope,
+  scopes,
+  runHooks,
+  apiOptions,
+  pluginOptions,
+  scopeOptions,
   scopeName,
   api,
   log
 }) {
-  context.method = 'post';
+  context.method = 'post'
 
   try {
     const { schema, schemaStructure, schemaRelationships } = await setupCommonRequest({
-      params, 
-      context, 
-      vars, 
-      scopes, 
-      scopeOptions, 
-      scopeName, 
+      params,
+      context,
+      vars,
+      scopes,
+      scopeOptions,
+      scopeName,
       api,
       helpers
-    });
+    })
 
     // Run early hooks for pre-processing (e.g., file handling)
-    await runHooks('beforeProcessing');
-    await runHooks('beforeProcessingPost');
+    await runHooks('beforeProcessing')
+    await runHooks('beforeProcessingPost')
 
     // Validate POST payload to ensure it follows JSON:API format and references valid resources.
     // This checks the payload has required 'data' object with 'type' and 'attributes', validates
     // that data.type matches a real resource type (preventing creation of non-existent resources),
     // and ensures any relationships reference valid resource types with proper ID format.
     // Example: data.type: 'articles' must be a registered scope, relationships.author must reference 'users'.
-    validatePostPayload(context.inputRecord, scopes);
-    
+    validatePostPayload(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 } = await processRelationships(
       scope,
       { context }
-    );
+    )
 
     // Merge belongsTo updates into attributes before validation (like PUT/PATCH do)
     if (Object.keys(belongsToUpdates).length > 0) {
       context.inputRecord.data.attributes = {
         ...context.inputRecord.data.attributes,
         ...belongsToUpdates
-      };
+      }
     }
 
-    await validateResourceAttributesBeforeWrite({ 
-      context, 
-      schema, 
-      belongsToUpdates, 
+    await validateResourceAttributesBeforeWrite({
+      context,
+      schema,
+      belongsToUpdates,
       runHooks
-    });
+    })
 
     if (context.inputRecord?.data) {
-      const inputData = context.inputRecord.data;
+      const inputData = context.inputRecord.data
       context.minimalRecord = {
         type: scopeName,
         ...(inputData.id !== undefined && inputData.id !== null ? { id: String(inputData.id) } : {}),
         attributes: structuredClone(inputData.attributes || {}),
         relationships: structuredClone(inputData.relationships || {})
-      };
+      }
     }
 
     // Centralised checkPermissions function
     await scope.checkPermissions({
       method: 'post',
       originalContext: context,
-    });
+    })
+
+    await runHooks('beforeDataCall')
+    await runHooks('beforeDataCallPost')
 
-    await runHooks('beforeDataCall');
-    await runHooks('beforeDataCallPost');
-    
     // Apply field setters after validation and before storage
     if (context.inputRecord?.data?.attributes) {
       context.inputRecord.data.attributes = await applyFieldSetters(
@@ -111,18 +111,18 @@ export default async function postMethod({
         context,
         api,
         helpers
-      );
+      )
     }
-    
+
     // Create the main record - storage helper should return the created record with its ID
     context.id = await helpers.dataPost({
       scopeName,
       context
-    });
-    
-    await runHooks('afterDataCallPost');
-    await runHooks('afterDataCall');
-    
+    })
+
+    await runHooks('afterDataCallPost')
+    await runHooks('afterDataCall')
+
     // Process many-to-many relationships after main record creation
     for (const { relName, relDef, relData } of manyToManyRelationships) {
       if (api.anyapi?.links?.attachMany && relDef?.through) {
@@ -132,15 +132,15 @@ export default async function postMethod({
           relName,
           relDef,
           relData,
-        });
-        continue;
+        })
+        continue
       }
 
       // Validate pivot resource exists
-      validatePivotResource(scopes, relDef, relName);
-      await createPivotRecords(api, context.id, relDef, relData, context.transaction);
+      validatePivotResource(scopes, relDef, relName)
+      await createPivotRecords(api, context.id, relDef, relData, context.transaction)
     }
-    
+
     const ret = await handleRecordReturnAfterWrite({
       context,
       scopeName,
@@ -153,17 +153,16 @@ export default async function postMethod({
       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, 'POST', scopeName, log, runHooks);
+    await handleWriteMethodError(error, context, 'POST', scopeName, log, runHooks)
   }
 }