json-rest-api 1.0.14 → 1.0.16

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

@@ -1,62 +1,61 @@
-
-import { RestApiResourceError, RestApiValidationError, RestApiPayloadError } from "../../../lib/rest-api-errors.js";
-import { findRelationshipDefinition, handleWriteMethodError } from "./common.js";
+import { RestApiResourceError, RestApiValidationError, RestApiPayloadError } from '../../../lib/rest-api-errors.js'
+import { findRelationshipDefinition, handleWriteMethodError } from './common.js'
 
 /**
  * DELETE RELATIONSHIP
  * Removes specific members from a to-many relationship
  * DELETE /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 remove
  * @returns {Promise<void>} 204 No Content
  */
-export default async function deleteRelationshipMethod({ params, context, vars, helpers, scope, scopes, runHooks, scopeName, api, log }) {
-  context.method = 'deleteRelationship';
-  context.id = params.id;
-  context.relationshipName = params.relationshipName;
-  context.schemaInfo = scopes[scopeName].vars.schemaInfo;
+export default async function deleteRelationshipMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeName, api, log }) {
+  context.method = 'deleteRelationship'
+  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);
+    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') {
       throw new RestApiValidationError(
         `Cannot DELETE from to-one relationship '${context.relationshipName}'`,
         { fields: ['data'] }
-      );
+      )
     }
 
     if (!Array.isArray(params.relationshipData)) {
-      throw new RestApiPayloadError('DELETE from relationship requires array of resource identifiers');
+      throw new RestApiPayloadError('DELETE from relationship requires array of resource identifiers')
     }
 
     // Check permissions
-    await runHooks('checkPermissions');
-    await runHooks('checkPermissionsDeleteRelationship');
+    await runHooks('checkPermissions')
+    await runHooks('checkPermissionsDeleteRelationship')
 
     // Verify parent exists
     const exists = await helpers.dataExists({
       scopeName,
-      context: {  db: context.db, id: context.id, schemaInfo: context.schemaInfo }
-    });
+      context: { db: context.db, id: context.id, schemaInfo: context.schemaInfo }
+    })
 
     if (!exists) {
-      throw new RestApiResourceError('Resource not found', { subtype: 'not_found' });
+      throw new RestApiResourceError('Resource not found', { subtype: 'not_found' })
     }
 
     // Remove relationships
@@ -68,26 +67,26 @@ export default async function deleteRelationshipMethod({ params, context, vars,
           relName: context.relationshipName,
           relDef,
           relData: params.relationshipData,
-        });
+        })
       } else {
-        const knex = api.knex?.instance || helpers.db;
-        const pivotResource = relDef.through;
-        const pivotScope = api.resources[pivotResource];
-        const pivotTable = pivotScope?.vars?.schemaInfo?.tableName || pivotResource;
-        const localKey = relDef.foreignKey;
-        const foreignKey = relDef.otherKey;
+        const knex = api.knex?.instance || helpers.db
+        const pivotResource = relDef.through
+        const pivotScope = api.resources[pivotResource]
+        const pivotTable = pivotScope?.vars?.schemaInfo?.tableName || pivotResource
+        const localKey = relDef.foreignKey
+        const foreignKey = relDef.otherKey
 
         for (const identifier of params.relationshipData) {
           await knex(pivotTable)
             .where(localKey, context.id)
             .where(foreignKey, identifier.id)
             .delete()
-            .transacting(context.transaction);
+            .transacting(context.transaction)
         }
       }
     } else {
       // Null out foreign keys for hasMany
-      const targetType = relDef.target;
+      const targetType = relDef.target
       for (const identifier of params.relationshipData) {
         await api.resources[targetType].patch({
           id: identifier.id,
@@ -100,20 +99,19 @@ export default async function deleteRelationshipMethod({ params, context, vars,
           },
           transaction: context.transaction,
           simplified: false
-        });
+        })
       }
     }
 
-    await runHooks('finish');
-    await runHooks('finishDeleteRelationship');
+    await runHooks('finish')
+    await runHooks('finishDeleteRelationship')
 
     if (context.shouldCommit) {
-      await context.transaction.commit();
+      await context.transaction.commit()
     }
 
-    return; // 204 No Content
-
+    // 204 No Content
   } catch (error) {
-    await handleWriteMethodError(error, context, 'DELETE_RELATIONSHIP', scopeName, log, runHooks);
+    await handleWriteMethodError(error, context, 'DELETE_RELATIONSHIP', scopeName, log, runHooks)
   }
 }

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

@@ -1,5 +1,5 @@
-import { RestApiResourceError } from '../../../lib/rest-api-errors.js';
-import { handleWriteMethodError } from './common.js';
+import { RestApiResourceError } from '../../../lib/rest-api-errors.js'
+import { handleWriteMethodError } from './common.js'
 
 /**
  * DELETE
@@ -7,100 +7,98 @@ import { handleWriteMethodError } from './common.js';
  * Returns 204 No Content on success, indicating the resource has been removed.
  * This method does not return the deleted resource.
  */
-export default async function deleteMethod({ 
-  params, 
-  context, 
-  vars, 
-  helpers, 
-  scope, 
-  scopes, 
-  runHooks, 
-  apiOptions, 
-  pluginOptions, 
-  scopeOptions, 
+export default async function deleteMethod ({
+  params,
+  context,
+  vars,
+  helpers,
+  scope,
+  scopes,
+  runHooks,
+  apiOptions,
+  pluginOptions,
+  scopeOptions,
   scopeName,
   api,
   log
 }) {
   // Make the method available to all hooks
-  context.method = 'delete';
-  
+  context.method = 'delete'
+
   // Set the ID in context
-  context.id = params.id;
-  
+  context.id = params.id
+
   // Set scopeName in context (needed for broadcasting)
-  context.scopeName = scopeName;
-  
+  context.scopeName = scopeName
+
   // Set schema info even for DELETE (needed by storage layer)
-  context.schemaInfo = scopes[scopeName].vars.schemaInfo;
-  
+  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.db = context.transaction || api.knex.instance;
-  
+  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 {
     // No payload validation needed for DELETE
-    
+
     // Fetch minimal record for authorization and logging
     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.originalMinimalRecord = minimalRecord;
-    context.minimalRecord = minimalRecord;
-    
+
+    context.originalMinimalRecord = minimalRecord
+    context.minimalRecord = minimalRecord
+
     // Centralised checkPermissions function
     await scope.checkPermissions({
       method: 'delete',
       originalContext: context,
-    });
-    
+    })
+
     // Before data operations
-    await runHooks('beforeDataCall');
-    await runHooks('beforeDataCallDelete');
-    
+    await runHooks('beforeDataCall')
+    await runHooks('beforeDataCallDelete')
+
     // Initialize record context for hooks
-    context.record = {};
-    
+    context.record = {}
+
     // Call the storage helper
     await helpers.dataDelete({
       scopeName,
       context
-    });
-    
-    await runHooks('afterDataCallDelete');
-    await runHooks('afterDataCall');
-    
+    })
+
+    await runHooks('afterDataCallDelete')
+    await runHooks('afterDataCall')
+
     // No return record for DELETE (204 No Content)
-    
-    await runHooks('finish');
-    await runHooks('finishDelete');
-    
+
+    await runHooks('finish')
+    await runHooks('finishDelete')
+
     // Commit transaction if we created it
     if (context.shouldCommit) {
-      await context.transaction.commit();
-      await runHooks('afterCommit');
+      await context.transaction.commit()
+      await runHooks('afterCommit')
     }
-    
+
     // DELETE typically returns void/undefined (204 No Content)
-    return;
-    
   } catch (error) {
-    await handleWriteMethodError(error, context, 'DELETE', scopeName, log, runHooks);
+    await handleWriteMethodError(error, context, 'DELETE', scopeName, log, runHooks)
   }
-}
+}