json-rest-api 1.0.6 → 1.0.8

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

@@ -0,0 +1,115 @@
+
+import { RestApiResourceError } from "../../../lib/rest-api-errors.js";
+import { findRelationshipDefinition } 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 }) {
+  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.db = context.transaction || api.knex.instance
+
+  try {
+    // Validate
+    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.hasMany && !relDef.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');
+    }
+
+    // Check permissions
+    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 }
+    });
+
+    if (!exists) {
+      throw new RestApiResourceError('Resource not found', { subtype: 'not_found' });
+    }
+
+    // Remove relationships
+    if (relDef.manyToMany || (relDef.hasMany && relDef.through)) {
+      const manyToManyDef = relDef.manyToMany || {
+        through: relDef.through,
+        foreignKey: relDef.foreignKey,
+        otherKey: relDef.otherKey
+      };
+
+      const knex = api.knex?.instance || helpers.db;
+      const pivotResource = manyToManyDef.through;
+      const pivotScope = api.resources[pivotResource];
+      const pivotTable = pivotScope?.vars?.schemaInfo?.tableName || pivotResource;
+      const localKey = manyToManyDef.foreignKey;
+      const foreignKey = manyToManyDef.otherKey;
+
+      for (const identifier of params.relationshipData) {
+        await knex(pivotTable)
+          .where(localKey, context.id)
+          .where(foreignKey, identifier.id)
+          .delete()
+          .transacting(context.transaction);
+      }
+    } else {
+      // Null out foreign keys for hasMany
+      const targetType = relDef.hasMany;
+      for (const identifier of params.relationshipData) {
+        await api.resources[targetType].patch({
+          id: identifier.id,
+          inputRecord: {
+            data: {
+              type: targetType,
+              id: identifier.id,
+              attributes: { [relDef.foreignKey]: null }
+            }
+          },
+          transaction: context.transaction,
+          simplified: false
+        });
+      }
+    }
+
+    await runHooks('finish');
+    await runHooks('finishDeleteRelationship');
+
+    if (context.shouldCommit) {
+      await context.transaction.commit();
+    }
+
+    return; // 204 No Content
+
+  } catch (error) {
+    await handleWriteMethodError(error, context, 'DELETE_RELATIONSHIP', scopeName, log);
+  }
+}

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

@@ -0,0 +1,109 @@
+import { RestApiResourceError } from '../../../lib/rest-api-errors.js';
+import { handleWriteMethodError } from './common.js';
+
+/**
+ * DELETE
+ * Permanently deletes a resource.
+ * 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, 
+  scopeName,
+  api,
+  log
+}) {
+  // Make the method available to all hooks
+  context.method = 'delete';
+  
+  // Set the ID in context
+  context.id = params.id;
+  
+  // Set scopeName in context (needed for broadcasting)
+  context.scopeName = scopeName;
+  
+  // Set schema info even for DELETE (needed by storage layer)
+  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;
+  
+  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`,
+        { 
+          subtype: 'not_found',
+          resourceType: scopeName,
+          resourceId: context.id
+        }
+      );
+    }
+    
+    context.originalMinimalRecord = minimalRecord;
+    context.minimalRecord = minimalRecord;
+    
+    // Centralised checkPermissions function
+    await scope.checkPermissions({
+      method: 'delete',
+      auth: context.auth,
+      id: context.id,
+      minimalRecord: context.minimalRecord,
+      transaction: context.transaction
+    });
+    
+    // Before data operations
+    await runHooks('beforeDataCall');
+    await runHooks('beforeDataCallDelete');
+    
+    // Initialize record context for hooks
+    context.record = {};
+    
+    // Call the storage helper
+    await helpers.dataDelete({
+      scopeName,
+      context
+    });
+    
+    await runHooks('afterDataCallDelete');
+    await runHooks('afterDataCall');
+    
+    // No return record for DELETE (204 No Content)
+    
+    await runHooks('finish');
+    await runHooks('finishDelete');
+    
+    // Commit transaction if we created it
+    if (context.shouldCommit) {
+      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);
+  }
+}

package/plugins/core/rest-api-plugin-methods/enrich-attributes.js

@@ -0,0 +1,186 @@
+import { filterHiddenFields } from '../lib/querying-writing/field-utils.js';
+
+/**
+ * enrichAttributes
+ * Runs the enrichAttributes hook for a specific scope to allow plugins to modify attributes
+ * before they are returned to the client. This is a scope method so each resource type
+ * can have its own attribute enrichment logic.
+ * 
+ * 
+ */
+export default async function enrichAttributesMethod({ context, params, runHooks, scopeName, scopes, api, helpers }) {
+  // Extract parameters passed to enrichAttributes
+  // - attributes: The raw attributes from database
+  // - parentContext: The context from the calling method (has queryParams, transaction, etc.)
+  // - requestedComputedFields: Which computed fields to calculate (from sparse fieldsets)
+  // - isMainResource: Whether this is the main resource or an included one
+  // - computedDependencies: Fields fetched only for computation (to be removed)
+    // Extract parameters passed to enrichAttributes
+      // - attributes: The raw attributes from database
+      // - parentContext: The context from the calling method (has queryParams, transaction, etc.)
+      // - requestedComputedFields: Which computed fields to calculate (from sparse fieldsets)
+      // - isMainResource: Whether this is the main resource or an included one
+      // - computedDependencies: Fields fetched only for computation (to be removed)
+      const { attributes, parentContext, requestedComputedFields, isMainResource, computedDependencies } = params || {};
+
+      // Return empty object if no attributes provided
+      if (!attributes) {
+        return {};
+      }
+
+      // Get schema, computed field definitions
+      const schemaStructure = scopes[scopeName]?.vars?.schemaInfo?.schemaStructure || {};
+      const computedFields = scopes[scopeName]?.vars?.schemaInfo?.computed || {};
+      const fieldGetters = scopes[scopeName]?.vars?.schemaInfo?.fieldGetters || {};
+      const sortedGetterFields = scopes[scopeName]?.vars?.schemaInfo?.sortedGetterFields || [];
+
+      // Make a copy of attributes for transformation
+      let transformedAttributes = { ...attributes };
+
+      // STEP 1: Apply field getters in dependency order (before filtering)
+      // This ensures getters see all fields including hidden ones
+      for (const fieldName of sortedGetterFields) {
+        // Only process if field exists in attributes
+        if (fieldName in transformedAttributes) {
+          const getterInfo = fieldGetters[fieldName];
+          try {
+            const getterContext = {
+              attributes: transformedAttributes, // Current state with previous getters applied
+              fieldName,
+              originalValue: attributes[fieldName], // Original untransformed value
+              originalAttributes: attributes, // All original attributes
+              record: transformedAttributes, // Alias for compatibility
+              parentContext,
+              scopeName,
+              api,
+              helpers,
+              isMainResource: isMainResource !== false
+            };
+            
+            // Apply getter (can be async)
+            transformedAttributes[fieldName] = await getterInfo.getter(
+              transformedAttributes[fieldName],
+              getterContext
+            );
+          } catch (error) {
+            console.error(`Error in getter for field '${fieldName}' in ${scopeName}:`, error);
+            // Keep current value on error (don't break the whole request)
+          }
+        }
+      }
+
+      // Filter hidden fields from attributes based on visibility rules
+      // This removes hidden:true fields and normallyHidden:true fields (unless requested)
+      const requestedFields = parentContext?.queryParams?.fields?.[scopeName];
+      const filteredAttributes = filterHiddenFields(transformedAttributes, { structure: schemaStructure }, requestedFields);
+      
+      // Handle virtual fields - they need to be added from parent context if available
+      // Virtual fields come from input and need to be preserved in responses
+      if (parentContext && parentContext.inputRecord?.data?.attributes) {
+        const inputAttrs = parentContext.inputRecord.data.attributes;
+        Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
+          if (fieldDef.virtual === true && fieldName in inputAttrs && inputAttrs[fieldName] !== undefined && inputAttrs[fieldName] !== null) {
+            // Add virtual field to filtered attributes if not already there
+            if (!(fieldName in filteredAttributes)) {
+              filteredAttributes[fieldName] = inputAttrs[fieldName];
+            }
+          }
+        });
+      }
+      
+      // Now handle sparse fieldsets for virtual fields
+      if (requestedFields && requestedFields.length > 0) {
+        const requestedFieldsList = typeof requestedFields === 'string' ? 
+          requestedFields.split(',').map(f => f.trim()) : requestedFields;
+        
+        // Remove virtual fields that weren't requested
+        Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
+          if (fieldDef.virtual === true && fieldName in filteredAttributes) {
+            if (!requestedFieldsList.includes(fieldName)) {
+              delete filteredAttributes[fieldName];
+            }
+          }
+        });
+      }
+
+      // Determine which computed fields to calculate
+      // We only compute fields that are requested to optimize performance
+      let fieldsToCompute = [];
+      if (requestedComputedFields) {
+        // Explicit list provided (from sparse fieldsets)
+        // Example: ?fields[products]=name,profit_margin -> only compute profit_margin
+        fieldsToCompute = requestedComputedFields;
+      } else if (isMainResource || !parentContext?.queryParams?.fields) {
+        // No sparse fieldsets or this is the main resource - compute all fields
+        // This ensures all computed fields are available when no filtering is applied
+        fieldsToCompute = Object.keys(computedFields);
+      }
+
+      // Create compute context with all available resources
+      // IMPORTANT: We pass the TRANSFORMED attributes (after getters) to compute functions
+      // This ensures computed fields see the getter-processed values
+      // Example: if price getter converts string to number, profit_margin sees the number
+      const computeContext = {
+        attributes: transformedAttributes,   // Transformed attributes after getters
+        record: { ...transformedAttributes }, // Full record for convenience
+        context: parentContext,       
+        helpers,                             // API helpers for complex operations
+        api,                                 // Full API instance
+      };
+
+      // Auto-compute fields that have compute functions
+      for (const fieldName of fieldsToCompute) {
+        const fieldDef = computedFields[fieldName];
+        if (fieldDef && fieldDef.compute) {
+          try {
+            // Call the compute function with full context
+            // Example: profit_margin compute gets { attributes: { price: 100, cost: 60 } }
+            // and returns: ((100 - 60) / 100 * 100) = "40.00"
+            filteredAttributes[fieldName] = await fieldDef.compute(computeContext);
+          } catch (error) {
+            // Log error but don't fail the request - computed fields shouldn't break API
+            console.error(`Error computing field '${fieldName}' for ${scopeName}:`, error);
+            filteredAttributes[fieldName] = null;
+          }
+        }
+      }
+
+      // Remove fields that were only fetched as dependencies
+      // This is the key to the dependency resolution feature:
+      // 1. We fetched dependencies from DB (e.g., 'cost' for profit_margin)
+      // 2. We used them in compute functions
+      // 3. Now we remove them if they weren't explicitly requested
+      // Example: User requests profit_margin, we fetch cost, compute, then remove cost
+      const finalAttributes = { ...filteredAttributes };
+      if (requestedFields && computedDependencies && computedDependencies.length > 0) {
+        // Parse requested fields if it's a string
+        const requested = typeof requestedFields === 'string'
+          ? requestedFields.split(',').map(f => f.trim()).filter(f => f)
+          : requestedFields;
+
+        for (const dep of computedDependencies) {
+          // Only remove if it wasn't explicitly requested
+          // Example: 'cost' is removed unless user explicitly asked for it
+          if (!requested.includes(dep)) {
+            delete finalAttributes[dep];
+          }
+        }
+      }
+
+      // Create context for enrichAttributes hooks
+      Object.assign(context, {
+        parentContext,
+        attributes: finalAttributes,  // Use the final attributes after dependency removal
+        computedFields,
+        requestedComputedFields: fieldsToCompute,
+        scopeName,
+        helpers,
+        api
+      });
+
+      // Run enrichAttributes hooks for additional/override computations
+      await runHooks('enrichAttributes');
+
+      // Return the attributes from context, which hooks may have modified
+      return context.attributes;
+    };