json-rest-api 1.0.14 → 1.0.15

package/plugins/core/lib/writing/many-to-many-manipulations.js

@@ -1,13 +1,13 @@
-import { RestApiResourceError } from '../../../../lib/rest-api-errors.js';
-import { transformSimplifiedToJsonApi } from '../querying-writing/simplified-helpers.js';
+import { RestApiResourceError } from '../../../../lib/rest-api-errors.js'
+import { transformSimplifiedToJsonApi } from '../querying-writing/simplified-helpers.js'
 
 /**
  * Updates many-to-many relationships intelligently by synchronizing pivot table records
- * 
+ *
  * @param {Object} scope - The scope object (not used directly, for consistency)
  * @param {Object} deps - Dependencies object
  * @returns {Promise<void>}
- * 
+ *
  * @example
  * // Input: Article currently has tags [1, 2], want to change to [1, 3]
  * const deps = {
@@ -26,29 +26,29 @@ import { transformSimplifiedToJsonApi } from '../querying-writing/simplified-hel
  *     transaction: trx
  *   }
  * };
- * 
+ *
  * // Before: article_tags table
  * // article_id | tag_id | created_at
- * // 100        | 1      | 2024-01-01  
+ * // 100        | 1      | 2024-01-01
  * // 100        | 2      | 2024-01-02
- * 
+ *
  * await updateManyToManyRelationship(null, deps);
- * 
- * // After: article_tags table  
+ *
+ * // After: article_tags table
  * // article_id | tag_id | created_at
  * // 100        | 1      | 2024-01-01  (preserved!)
  * // 100        | 3      | 2024-12-01  (new)
  * // Tag 2 was deleted, Tag 1 kept its metadata
- * 
+ *
  * @example
  * // Input: Pivot table has extra fields to preserve
  * // article_tags has: article_id, tag_id, display_order, featured
- * 
+ *
  * // Current data:
  * // article_id | tag_id | display_order | featured
  * // 100        | 1      | 1            | true
  * // 100        | 2      | 2            | false
- * 
+ *
  * const deps = {
  *   context: {
  *     resourceId: '100',
@@ -58,14 +58,14 @@ import { transformSimplifiedToJsonApi } from '../querying-writing/simplified-hel
  *     ]
  *   }
  * };
- * 
+ *
  * await updateManyToManyRelationship(null, deps);
- * 
+ *
  * // Result:
- * // article_id | tag_id | display_order | featured  
+ * // article_id | tag_id | display_order | featured
  * // 100        | 1      | 1            | true      (preserved!)
  * // 100        | 5      | NULL         | NULL      (new with defaults)
- * 
+ *
  * @example
  * // Input: Clear all relationships
  * const deps = {
@@ -74,23 +74,23 @@ import { transformSimplifiedToJsonApi } from '../querying-writing/simplified-hel
  *     relData: []  // Empty array means remove all
  *   }
  * };
- * 
+ *
  * await updateManyToManyRelationship(null, deps);
  * // All article_tags records for article 100 are deleted
- * 
+ *
  * @description
  * Used by:
  * - relationship-processor.js calls this for many-to-many updates
  * - Used in PATCH operations to sync relationships
  * - Also used in PUT operations (replaces deleteExistingPivotRecords pattern)
- * 
+ *
  * Purpose:
  * - Intelligently syncs pivot table to match desired state
  * - Preserves existing pivot records that should remain (with their metadata)
  * - Only deletes records that should be removed
  * - Only creates records that are new
  * - Much better than delete-all-then-recreate pattern
- * 
+ *
  * Data flow:
  * 1. Queries existing pivot records for the resource
  * 2. Compares existing IDs with desired IDs
@@ -102,73 +102,73 @@ import { transformSimplifiedToJsonApi } from '../querying-writing/simplified-hel
  */
 export const updateManyToManyRelationship = async (scope, deps) => {
   // Extract values from deps
-  const { api, context } = deps;
-  const { resourceId, relDef, relData, transaction: trx } = context;
-  
+  const { api, context } = deps
+  const { resourceId, relDef, relData, transaction: trx } = context
+
   // Get the knex instance from the pivot scope
-  const pivotScope = api.resources[relDef.through];
+  const pivotScope = api.resources[relDef.through]
   if (!pivotScope) {
-    throw new Error(`Pivot table resource '${relDef.through}' not found`);
+    throw new Error(`Pivot table resource '${relDef.through}' not found`)
   }
-  
+
   // Get the actual database table name (might be different from scope name)
-  const tableName = pivotScope.vars.schemaInfo.tableName || relDef.through;
-  
+  const tableName = pivotScope.vars.schemaInfo.tableName || relDef.through
+
   // Get existing pivot records directly from database
   const existingRecords = await trx(tableName)
     .where(relDef.foreignKey, resourceId)
-    .select(relDef.otherKey);
-  
+    .select(relDef.otherKey)
+
   // Create sets for efficient comparison
-  const existingIds = new Set(existingRecords.map(r => String(r[relDef.otherKey])));
-  const newIds = new Set(relData.map(r => String(r.id)));
-  
+  const existingIds = new Set(existingRecords.map(r => String(r[relDef.otherKey])))
+  const newIds = new Set(relData.map(r => String(r.id)))
+
   // Determine what to delete and add
-  const toDelete = [...existingIds].filter(id => !newIds.has(id));
-  const toAdd = [...newIds].filter(id => !existingIds.has(id));
-  
+  const toDelete = [...existingIds].filter(id => !newIds.has(id))
+  const toAdd = [...newIds].filter(id => !existingIds.has(id))
+
   // Validate related resources exist if needed (do this before any changes)
   if (relDef.validateExists !== false && toAdd.length > 0) {
     for (const relatedId of toAdd) {
-      const related = relData.find(r => String(r.id) === relatedId);
+      const related = relData.find(r => String(r.id) === relatedId)
       try {
         await api.resources[related.type].get({
           id: related.id,
           transaction: trx
-        });
+        })
       } catch (error) {
         throw new RestApiResourceError(
           `Related ${related.type} with id ${related.id} not found`,
-          { 
+          {
             subtype: 'not_found',
-            resourceType: related.type, 
-            resourceId: related.id 
+            resourceType: related.type,
+            resourceId: related.id
           }
-        );
+        )
       }
     }
   }
-  
+
   // Bulk delete records that should be removed
   if (toDelete.length > 0) {
     await trx(tableName)
       .where(relDef.foreignKey, resourceId)
       .whereIn(relDef.otherKey, toDelete)
-      .delete();
+      .delete()
   }
-  
+
   // Bulk insert new records
   if (toAdd.length > 0) {
     const recordsToInsert = toAdd.map(relatedId => ({
       [relDef.foreignKey]: resourceId,
       [relDef.otherKey]: relatedId
-    }));
-    
-    await trx(tableName).insert(recordsToInsert);
+    }))
+
+    await trx(tableName).insert(recordsToInsert)
   }
-  
+
   // Records that exist in both are automatically preserved with their pivot data
-};
+}
 
 // Note: deleteExistingPivotRecords has been removed in favor of using
 // updateManyToManyRelationship for all sync operations (including PUT).
@@ -177,14 +177,14 @@ export const updateManyToManyRelationship = async (scope, deps) => {
 
 /**
  * Creates new pivot table records for many-to-many relationships
- * 
+ *
  * @param {Object} api - The API instance with access to resources
  * @param {string|number} resourceId - The ID of the primary resource
  * @param {Object} relDef - The relationship definition
  * @param {Array} relData - Array of related resources to link
  * @param {Object} trx - Database transaction object
  * @returns {Promise<void>}
- * 
+ *
  * @example
  * // Input: Create article-tag relationships
  * const relDef = {
@@ -197,21 +197,21 @@ export const updateManyToManyRelationship = async (scope, deps) => {
  *   { type: 'tags', id: '20' },
  *   { type: 'tags', id: '30' }
  * ];
- * 
+ *
  * await createPivotRecords(api, '100', relDef, relData, trx);
- * 
+ *
  * // Result: 3 new records in article_tags table
  * // article_id | tag_id
  * // 100        | 10
- * // 100        | 20  
+ * // 100        | 20
  * // 100        | 30
- * 
+ *
  * @example
  * // Input: Validation ensures related resources exist
  * const relData = [
  *   { type: 'tags', id: '999' }  // Non-existent tag
  * ];
- * 
+ *
  * try {
  *   await createPivotRecords(api, '100', relDef, relData, trx);
  * } catch (error) {
@@ -219,35 +219,35 @@ export const updateManyToManyRelationship = async (scope, deps) => {
  *   // "Related tags with id 999 not found"
  *   // Transaction rolled back, no records created
  * }
- * 
+ *
  * @example
  * // Input: Skip validation for performance
  * const relDef = {
  *   through: 'user_permissions',
- *   foreignKey: 'user_id', 
+ *   foreignKey: 'user_id',
  *   otherKey: 'permission_id',
  *   validateExists: false  // Skip GET requests
  * };
- * 
+ *
  * // With 100 permissions, saves 100 GET requests
  * await createPivotRecords(api, userId, relDef, permissions, trx);
- * 
+ *
  * // Risk: Could create orphaned relationships if permissions don't exist
  * // Benefit: Much faster for bulk operations when you trust the data
- * 
+ *
  * @description
  * Used by:
  * - relationship-processor.js for POST operations
  * - updateManyToManyRelationship internally for new relationships
  * - Any code that needs to create pivot records
- * 
+ *
  * Purpose:
  * - Creates pivot table records to link resources
  * - Validates related resources exist by default (referential integrity)
  * - Supports bulk insert for efficiency
  * - Works within transactions for atomicity
  * - Allows skipping validation when performance matters
- * 
+ *
  * Data flow:
  * 1. Validates pivot table resource exists
  * 2. Gets actual database table name
@@ -257,17 +257,17 @@ export const updateManyToManyRelationship = async (scope, deps) => {
  * 6. Returns (no data returned, throws on error)
  */
 export const createPivotRecords = async (api, resourceId, relDef, relData, trx) => {
-  if (relData.length === 0) return; // Early exit if nothing to create
-  
+  if (relData.length === 0) return // Early exit if nothing to create
+
   // Get pivot table info
-  const pivotScope = api.resources[relDef.through];
+  const pivotScope = api.resources[relDef.through]
   if (!pivotScope) {
-    throw new Error(`Pivot table resource '${relDef.through}' not found`);
+    throw new Error(`Pivot table resource '${relDef.through}' not found`)
   }
-  
+
   // Get the actual database table name (might be different from scope name)
-  const tableName = pivotScope.vars.schemaInfo.tableName || relDef.through;
-  
+  const tableName = pivotScope.vars.schemaInfo.tableName || relDef.through
+
   // Validate all related resources exist if needed (do this before any inserts)
   if (relDef.validateExists !== false) {
     for (const related of relData) {
@@ -275,26 +275,26 @@ export const createPivotRecords = async (api, resourceId, relDef, relData, trx)
         await api.resources[related.type].get({
           id: related.id,
           transaction: trx
-        });
+        })
       } catch (error) {
         throw new RestApiResourceError(
           `Related ${related.type} with id ${related.id} not found`,
-          { 
+          {
             subtype: 'not_found',
-            resourceType: related.type, 
-            resourceId: related.id 
+            resourceType: related.type,
+            resourceId: related.id
           }
-        );
+        )
       }
     }
   }
-  
+
   // Prepare records for bulk insert
   const recordsToInsert = relData.map(related => ({
     [relDef.foreignKey]: resourceId,
     [relDef.otherKey]: related.id
-  }));
-  
+  }))
+
   // Bulk insert all pivot records in a single query
-  await trx(tableName).insert(recordsToInsert);
-};
+  await trx(tableName).insert(recordsToInsert)
+}

package/plugins/core/lib/writing/relationship-processor.js

@@ -1,12 +1,12 @@
-import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
+import { RestApiValidationError } from '../../../../lib/rest-api-errors.js'
 
 /**
  * Processes JSON:API relationship data and converts to database operations
- * 
+ *
  * @param {Object} scope - The scope object containing schema info
  * @param {Object} deps - Dependencies object
  * @returns {Object} Object with belongsToUpdates and manyToManyRelationships arrays
- * 
+ *
  * @example
  * // Input: Simple belongsTo relationship
  * const inputRecord = {
@@ -23,13 +23,13 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  *     }
  *   }
  * };
- * 
+ *
  * // Schema has:
  * // author_id: { belongsTo: 'users', as: 'author' }
  * // category_id: { belongsTo: 'categories', as: 'category' }
- * 
+ *
  * const result = processRelationships(scope, { context: { inputRecord } });
- * 
+ *
  * // Output: Foreign keys extracted
  * // {
  * //   belongsToUpdates: {
@@ -38,7 +38,7 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * //   },
  * //   manyToManyRelationships: []
  * // }
- * 
+ *
  * @example
  * // Input: Polymorphic relationship
  * const inputRecord = {
@@ -51,7 +51,7 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  *     }
  *   }
  * };
- * 
+ *
  * // Schema relationships has:
  * // commentable: {
  * //   belongsToPolymorphic: {
@@ -60,9 +60,9 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * //     idField: 'commentable_id'
  * //   }
  * // }
- * 
+ *
  * const result = processRelationships(scope, { context: { inputRecord } });
- * 
+ *
  * // Output: Both type and id fields set
  * // {
  * //   belongsToUpdates: {
@@ -71,12 +71,12 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * //   },
  * //   manyToManyRelationships: []
  * // }
- * 
+ *
  * @example
  * // Input: Many-to-many relationship
  * const inputRecord = {
  *   data: {
- *     type: 'articles', 
+ *     type: 'articles',
  *     relationships: {
  *       tags: {
  *         data: [
@@ -87,7 +87,7 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  *     }
  *   }
  * };
- * 
+ *
  * // Schema relationships has:
  * // tags: {
  * //   type: 'manyToMany',
@@ -95,9 +95,9 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * //   foreignKey: 'article_id',
  * //   otherKey: 'tag_id'
  * // }
- * 
+ *
  * const result = processRelationships(scope, { context: { inputRecord } });
- * 
+ *
  * // Output: Many-to-many data collected
  * // {
  * //   belongsToUpdates: {},
@@ -114,7 +114,7 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * //     ]
  * //   }]
  * // }
- * 
+ *
  * @example
  * // Input: Clearing relationships
  * const inputRecord = {
@@ -125,9 +125,9 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  *     }
  *   }
  * };
- * 
+ *
  * const result = processRelationships(scope, { context: { inputRecord } });
- * 
+ *
  * // Output: Null for belongsTo, empty array for many-to-many
  * // {
  * //   belongsToUpdates: { author_id: null },
@@ -137,18 +137,18 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * //     relData: []  // Will delete all pivot records
  * //   }]
  * // }
- * 
+ *
  * @description
  * Used by:
  * - rest-api-knex-plugin's dataPut and dataPatch methods
  * - Called before database writes to prepare relationship updates
- * 
+ *
  * Purpose:
  * - Converts JSON:API relationship format to database operations
  * - Handles all relationship types: belongsTo, polymorphic, many-to-many
  * - Validates polymorphic types against allowed values
  * - Separates concerns: foreign keys vs pivot table operations
- * 
+ *
  * Data flow:
  * 1. Receives JSON:API document with relationships section
  * 2. Analyzes schema to determine relationship types
@@ -159,58 +159,58 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  */
 export const processRelationships = (scope, deps) => {
   // Extract values from scope
-  const { 
-    vars: { 
+  const {
+    vars: {
       schemaInfo: { schemaStructure: schemaFields, schemaRelationships: relationships }
     }
-  } = scope;
-  
+  } = scope
+
   // Extract values from deps
-  const { context } = deps;
-  const { inputRecord } = context;
-  const belongsToUpdates = {};
-  const manyToManyRelationships = [];
-  
+  const { context } = deps
+  const { inputRecord } = context
+  const belongsToUpdates = {}
+  const manyToManyRelationships = []
+
   if (!inputRecord.data.relationships) {
-    return { belongsToUpdates, manyToManyRelationships };
+    return { belongsToUpdates, manyToManyRelationships }
   }
-  
+
   for (const [relName, relData] of Object.entries(inputRecord.data.relationships)) {
-    const relDef = relationships?.[relName];
-    
+    const relDef = relationships?.[relName]
+
     // Find the schema field that defines this relationship
-    const schemaField = Object.entries(schemaFields).find(([fieldName, fieldDef]) => 
+    const schemaField = Object.entries(schemaFields).find(([fieldName, fieldDef]) =>
       fieldDef.as === relName
-    );
-    
+    )
+
     if (schemaField) {
-      const [fieldName, fieldDef] = schemaField;
-      
+      const [fieldName, fieldDef] = schemaField
+
       // Handle regular belongsTo (1:1)
       if (fieldDef.belongsTo) {
         if (relData.data === null) {
-          belongsToUpdates[fieldName] = null;
+          belongsToUpdates[fieldName] = null
         } else if (relData.data?.id) {
-          belongsToUpdates[fieldName] = relData.data.id;
+          belongsToUpdates[fieldName] = relData.data.id
         }
       }
     }
-    
+
     // Check for polymorphic belongsTo defined in relationships object (not as schema field)
     if (!schemaField && relDef?.belongsToPolymorphic && relData.data !== undefined) {
       if (relData.data === null) {
-        const { typeField, idField } = relDef.belongsToPolymorphic;
-        belongsToUpdates[typeField] = null;
-        belongsToUpdates[idField] = null;
+        const { typeField, idField } = relDef.belongsToPolymorphic
+        belongsToUpdates[typeField] = null
+        belongsToUpdates[idField] = null
       } else if (relData.data) {
-        const { type, id } = relData.data;
-        const { types, typeField, idField } = relDef.belongsToPolymorphic;
-        
+        const { type, id } = relData.data
+        const { types, typeField, idField } = relDef.belongsToPolymorphic
+
         // Validate type is allowed
         if (!types.includes(type)) {
           throw new RestApiValidationError(
             `Invalid type '${type}' for polymorphic relationship '${relName}'. Allowed types: ${types.join(', ')}`,
-            { 
+            {
               fields: [`data.relationships.${relName}.data.type`],
               violations: [{
                 field: `data.relationships.${relName}.data.type`,
@@ -218,14 +218,14 @@ export const processRelationships = (scope, deps) => {
                 message: `Type must be one of: ${types.join(', ')}`
               }]
             }
-          );
+          )
         }
-        
-        belongsToUpdates[typeField] = type;
-        belongsToUpdates[idField] = id;
+
+        belongsToUpdates[typeField] = type
+        belongsToUpdates[idField] = id
       }
     }
-    
+
     // Check relationship type and process accordingly
     if (relDef?.type === 'manyToMany' && relData.data !== undefined) {
       manyToManyRelationships.push({
@@ -236,10 +236,10 @@ export const processRelationships = (scope, deps) => {
           otherKey: relDef.otherKey
         },
         relData: relData.data || []  // null means empty array for many-to-many
-      });
+      })
     }
     // Note: hasOne and hasMany don't need processing here as they don't update the current record
   }
-  
-  return { belongsToUpdates, manyToManyRelationships };
-};
+
+  return { belongsToUpdates, manyToManyRelationships }
+}

package/plugins/core/rest-api-access.js

@@ -4,7 +4,7 @@ export const AccessPlugin = {
   name: 'rest-api-access',
   dependencies: ['rest-api'],
 
-  async install({ addHook, helpers, log, pluginOptions = {}, scopes }) {
+  async install ({ addHook, helpers, log, pluginOptions = {}, scopes }) {
     const ownershipOptions = pluginOptions.ownership || pluginOptions.autoOwnership || {}
 
     const config = {
@@ -105,7 +105,7 @@ export const AccessPlugin = {
       return storageAdapter.translateFilterValue(field, value)
     }
 
-    function registerBuiltinCheckers() {
+    function registerBuiltinCheckers () {
       state.authCheckers.set('public', () => true)
 
       state.authCheckers.set('authenticated', (context) => {
@@ -188,7 +188,7 @@ export const AccessPlugin = {
       }
     })
 
-    function setOwnerOnInput({ context, scopeName, scopes, scopeOptions }) {
+    function setOwnerOnInput ({ context, scopeName, scopes, scopeOptions }) {
       if (!config.ownership.enabled) return
       if (config.ownership.excludeResources.includes(scopeName)) return
       if (!context.auth?.userId) {
@@ -384,7 +384,7 @@ export const AccessPlugin = {
       helpers.auth = {}
     }
 
-    helpers.auth.requireAuth = function requireAuth(context) {
+    helpers.auth.requireAuth = function requireAuth (context) {
       if (!context.auth?.userId) {
         const error = new Error('Authentication required')
         error.statusCode = 401
@@ -393,7 +393,7 @@ export const AccessPlugin = {
       return context.auth
     }
 
-    helpers.auth.requireOwnership = function requireOwnership(context, resourceOrUserId) {
+    helpers.auth.requireOwnership = function requireOwnership (context, resourceOrUserId) {
       const auth = helpers.auth.requireAuth(context)
       const field = ownershipField()
 
@@ -424,11 +424,11 @@ export const AccessPlugin = {
       return auth
     }
 
-    helpers.auth.registerChecker = function registerChecker(name, checkerFn) {
+    helpers.auth.registerChecker = function registerChecker (name, checkerFn) {
       state.authCheckers.set(name, checkerFn)
     }
 
-    helpers.auth.checkPermission = async function checkPermission(context, rules, options = {}) {
+    helpers.auth.checkPermission = async function checkPermission (context, rules, options = {}) {
       if (!rules || rules.length === 0) return true
 
       const { existingRecord, scopeVars } = options
@@ -447,7 +447,7 @@ export const AccessPlugin = {
       return false
     }
 
-    helpers.auth.cleanup = function cleanup() {
+    helpers.auth.cleanup = function cleanup () {
       state.authCheckers.clear()
     }
   }