json-rest-api 1.0.13 → 1.0.15

package/plugins/core/lib/querying/knex-process-includes.js

@@ -1,13 +1,13 @@
-import { buildIncludedResources } from './knex-relationship-includes.js';
+import { buildIncludedResources } from './knex-relationship-includes.js'
 
 /**
  * Processes the ?include= parameter to load related resources efficiently
- * 
+ *
  * @param {Object} scope - The scope object for the primary resource
  * @param {Array<Object>} records - The primary records to load includes for
  * @param {Object} deps - Dependencies object containing log, scopes, knex, and context
  * @returns {Promise<Array<Object>>} Array of included resources in JSON:API format
- * 
+ *
  * @example
  * // Input: Articles with author relationship
  * const articles = [
@@ -15,37 +15,37 @@ import { buildIncludedResources } from './knex-relationship-includes.js';
  *   { id: 2, title: 'Second Article', author_id: 11 },
  *   { id: 3, title: 'Third Article', author_id: 10 }  // Same author as article 1
  * ];
- * 
+ *
  * const deps = {
- *   context: { 
+ *   context: {
  *     scopeName: 'articles',
  *     queryParams: { include: ['author'] },
  *     schemaInfo: { idProperty: 'id' }
  *   }
  * };
- * 
+ *
  * const included = await processIncludes(scope, articles, deps);
- * 
+ *
  * // Output: Deduplicated authors (only 2, not 3)
  * // [
  * //   { type: 'users', id: '10', attributes: { name: 'Alice', email: 'alice@example.com' } },
  * //   { type: 'users', id: '11', attributes: { name: 'Bob', email: 'bob@example.com' } }
  * // ]
- * 
+ *
  * @example
  * // Input: Nested includes with dot notation
  * const articles = [{ id: 1, title: 'Article', author_id: 10 }];
- * 
+ *
  * const deps = {
  *   context: {
- *     queryParams: { 
+ *     queryParams: {
  *       include: ['author', 'comments.user'] // Load author AND comment users
  *     }
  *   }
  * };
- * 
+ *
  * const included = await processIncludes(scope, articles, deps);
- * 
+ *
  * // Output: All related resources in flat array
  * // [
  * //   { type: 'users', id: '10', attributes: { name: 'Author' } },
@@ -54,41 +54,41 @@ import { buildIncludedResources } from './knex-relationship-includes.js';
  * //   { type: 'users', id: '20', attributes: { name: 'Commenter1' } },
  * //   { type: 'users', id: '21', attributes: { name: 'Commenter2' } }
  * // ]
- * 
+ *
  * @example
  * // Input: With sparse fieldsets limiting included data
  * const deps = {
  *   context: {
- *     queryParams: { 
+ *     queryParams: {
  *       include: ['author'],
- *       fields: { 
+ *       fields: {
  *         users: 'name'  // Only include name field for users
  *       }
  *     }
  *   }
  * };
- * 
+ *
  * const included = await processIncludes(scope, articles, deps);
- * 
+ *
  * // Output: Users with only requested fields
  * // [
  * //   { type: 'users', id: '10', attributes: { name: 'Alice' } }
  * //   // email field excluded due to sparse fieldset
  * // ]
- * 
+ *
  * @description
  * Used by:
  * - rest-api-knex-plugin's dataGet method when includes are requested
  * - rest-api-knex-plugin's dataQuery method for collection includes
  * - Called after primary records are fetched but before response assembly
- * 
+ *
  * Purpose:
  * - Implements JSON:API compound documents with primary data and includes
  * - Prevents N+1 queries by batch loading all related resources
  * - Handles complex nested includes like 'comments.author.company'
  * - Automatically deduplicates included resources
  * - Respects sparse fieldsets on included resources
- * 
+ *
  * Data flow:
  * 1. Receives primary records and include directives
  * 2. Parses include parameter (comma-separated, possibly nested with dots)
@@ -98,27 +98,27 @@ import { buildIncludedResources } from './knex-relationship-includes.js';
  */
 export const processIncludes = async (scope, records, deps) => {
   try {
-    const { log, scopes, knex, context, api } = deps;
-    
-    const scopeName = context.scopeName;
-    
+    const { log, scopes, knex, context, api } = deps
+
+    const scopeName = context.scopeName
+
     if (!scopeName) {
-      log.error('[PROCESS-INCLUDES] scopeName is undefined in context!', { 
+      log.error('[PROCESS-INCLUDES] scopeName is undefined in context!', {
         contextKeys: Object.keys(context || {})
-      });
-      throw new Error('scopeName is undefined in context');
+      })
+      throw new Error('scopeName is undefined in context')
     }
-    
-    const db = context.transaction || knex;
-    const queryParams = context.queryParams;
-    const idProperty = context.schemaInfo.idProperty;
-    
+
+    const db = context.transaction || knex
+    const queryParams = context.queryParams
+    const idProperty = context.schemaInfo.idProperty
+
     if (!queryParams.include) {
-      return [];
+      return []
     }
-    
-    log.debug('[PROCESS-INCLUDES] Processing includes:', queryParams.include);
-    
+
+    log.debug('[PROCESS-INCLUDES] Processing includes:', queryParams.include)
+
     const includeResult = await buildIncludedResources(
       {
         records,
@@ -135,17 +135,17 @@ export const processIncludes = async (scope, records, deps) => {
           capabilities: api?.knex?.capabilities
         }
       }
-    );
-    
+    )
+
     log.debug('[PROCESS-INCLUDES] Include result:', {
       includedCount: includeResult.included.length,
       types: [...new Set(includeResult.included.map(r => r.type))]
-    });
-    
-    return includeResult.included;
+    })
+
+    return includeResult.included
   } catch (error) {
-    const { log, context } = deps || {};
-    
+    const { log, context } = deps || {}
+
     if (log) {
       log.error('[PROCESS-INCLUDES] Error processing includes:', {
         scopeName: context?.scopeName,
@@ -153,15 +153,15 @@ export const processIncludes = async (scope, records, deps) => {
         includeParam: context?.queryParams?.include,
         error: error.message,
         stack: error.stack
-      });
+      })
     } else {
-      console.error('[PROCESS-INCLUDES] Error processing includes:', error);
+      console.error('[PROCESS-INCLUDES] Error processing includes:', error)
     }
-    
+
     const enhancedError = new Error(
       `Failed to process includes${context?.scopeName ? ` for scope '${context.scopeName}'` : ''}: ${error.message}`
-    );
-    enhancedError.originalError = error;
-    throw enhancedError;
+    )
+    enhancedError.originalError = error
+    throw enhancedError
   }
-};
+}

package/plugins/core/lib/querying/knex-query-helpers-base.js

@@ -1,53 +1,53 @@
 /**
  * Builds the SELECT clause for a Knex query, handling field selection and table prefixing
- * 
+ *
  * @param {Object} query - The Knex query builder instance
  * @param {string} tableName - The table name
  * @param {Array<string>|string} fieldsToSelect - Fields to select or '*'
  * @param {boolean} useTablePrefix - Whether to prefix fields with table name
  * @returns {Object} The modified query builder
- * 
+ *
  * @example
  * // Input: Basic query without specific fields
  * const query = knex('articles');
  * buildQuerySelection(query, 'articles', '*', false);
- * 
+ *
  * // Effect on query: No modification, Knex defaults to SELECT *
  * // SQL generated: SELECT * FROM articles
- * 
+ *
  * @example
  * // Input: Query with sparse fieldset
  * const query = knex('articles');
  * const fields = ['id', 'title', 'author_id'];
  * buildQuerySelection(query, 'articles', fields, false);
- * 
+ *
  * // Effect on query: Adds select() with specific fields
  * // SQL generated: SELECT id, title, author_id FROM articles
  * // Response will only include these 3 fields, reducing payload size
- * 
+ *
  * @example
  * // Input: Query with joins needing table prefixes
  * const query = knex('articles')
  *   .join('users', 'articles.author_id', 'users.id');
  * const fields = ['id', 'title', 'created_at as published'];
  * buildQuerySelection(query, 'articles', fields, true);
- * 
+ *
  * // Effect on query: Prefixes all fields with table name
  * // SQL generated: SELECT articles.id, articles.title, articles.created_at as published
  * // Prevents "column 'id' is ambiguous" errors since both tables have id
- * 
+ *
  * @description
  * Used by:
  * - knex-query-helpers.js calls this when building queries with sparse fieldsets
  * - rest-api-knex-plugin uses this in dataQuery to optimize SELECT clauses
  * - Called whenever fields parameter limits which attributes to return
- * 
+ *
  * Purpose:
  * - Implements JSON:API sparse fieldsets by selecting only requested fields
  * - Prevents ambiguous column errors in queries with joins
  * - Reduces database transfer by not selecting unnecessary columns
  * - Handles field aliases (e.g., "created_at as published")
- * 
+ *
  * Data flow:
  * 1. Query parser extracts fields parameter (e.g., fields[articles]=title,author)
  * 2. This function adds appropriate SELECT clause to query
@@ -60,50 +60,50 @@ export const buildQuerySelection = (
   tableName,
   fieldsToSelect,
   useTablePrefix = false,
-  options = {},
+  options = {}
 ) => {
-  const translateColumn = options.translateColumn;
+  const translateColumn = options.translateColumn
 
   const applyTranslation = (field, aliasForField) => {
     if (translateColumn) {
-      const translated = translateColumn(field, aliasForField);
+      const translated = translateColumn(field, aliasForField)
       if (translated) {
-        return translated;
+        return translated
       }
     }
 
     if (aliasForField) {
-      return `${aliasForField}.${field}`;
+      return `${aliasForField}.${field}`
     }
-    return field;
-  };
+    return field
+  }
 
-  const targetAlias = useTablePrefix ? tableName : null;
+  const targetAlias = useTablePrefix ? tableName : null
 
   if (fieldsToSelect === '*') {
-    const translated = translateColumn ? translateColumn('*', targetAlias) : null;
+    const translated = translateColumn ? translateColumn('*', targetAlias) : null
     if (translated) {
-      return query.select(translated);
+      return query.select(translated)
     }
-    return useTablePrefix ? query.select(`${tableName}.*`) : query;
+    return useTablePrefix ? query.select(`${tableName}.*`) : query
   }
 
   const fieldsArray = Array.isArray(fieldsToSelect)
     ? fieldsToSelect
-    : Array.from(fieldsToSelect || []);
+    : Array.from(fieldsToSelect || [])
 
   const translatedFields = fieldsArray.map((field) => {
-    if (typeof field !== 'string') return field;
+    if (typeof field !== 'string') return field
 
-    const aliasMatch = field.match(/\s+as\s+/i);
+    const aliasMatch = field.match(/\s+as\s+/i)
     if (aliasMatch) {
-      const [source, alias] = field.split(/\s+as\s+/i);
-      const translatedSource = applyTranslation(source.trim(), targetAlias);
-      return `${translatedSource} as ${alias.trim()}`;
+      const [source, alias] = field.split(/\s+as\s+/i)
+      const translatedSource = applyTranslation(source.trim(), targetAlias)
+      return `${translatedSource} as ${alias.trim()}`
     }
 
-    return applyTranslation(field.trim(), targetAlias);
-  });
+    return applyTranslation(field.trim(), targetAlias)
+  })
 
-  return query.select(translatedFields);
-};
+  return query.select(translatedFields)
+}