json-rest-api 1.0.7 → 1.0.8

package/plugins/core/lib/querying-writing/default-data-helpers.js

@@ -0,0 +1,72 @@
+/**
+ * Default data helper implementations that instruct users to install a storage plugin
+ * 
+ * @description
+ * These default implementations ensure the REST API plugin fails gracefully
+ * when no storage plugin is installed. Each method throws a descriptive error
+ * guiding users to install a storage implementation.
+ * 
+ * @example
+ * // When no storage plugin is installed:
+ * try {
+ *   await api.resources.articles.get({ id: 1 });
+ * } catch (error) {
+ *   console.log(error.message);
+ *   // "No storage implementation for get. Install a storage plugin."
+ * }
+ * 
+ * @example
+ * // After installing rest-api-knex-plugin:
+ * api.use(RestApiKnexPlugin, { knex });
+ * // Now data helpers are replaced with actual implementations
+ * const article = await api.resources.articles.get({ id: 1 });
+ * // Works! Returns article from database
+ * 
+ * Used by:
+ * - rest-api-plugin sets these as initial data helpers
+ * - Storage plugins replace these with actual implementations
+ * 
+ * Purpose:
+ * - Provides clear error messages when storage is missing
+ * - Ensures REST API plugin can be installed independently
+ * - Allows storage plugins to be swapped without changing API
+ * 
+ * Data flow:
+ * 1. REST API plugin initializes with these defaults
+ * 2. User tries to use API without storage plugin
+ * 3. Clear error message guides them to install storage
+ * 4. Storage plugin replaces these with real implementations
+ */
+export const defaultDataHelpers = {
+  dataExists: async function(scope, deps) {
+    throw new Error(`No storage implementation for exists. Install a storage plugin.`);
+  },
+
+  dataGet: async function(scope, deps) {
+    throw new Error(`No storage implementation for get. Install a storage plugin.`);
+  },
+
+  dataGetMinimal: async function(scope, deps) {
+    throw new Error(`No storage implementation for getMinimal. Install a storage plugin.`);
+  },
+  
+  dataQuery: async function(scope, deps) {
+    throw new Error(`No storage implementation for query. Install a storage plugin.`);
+  },
+  
+  dataPost: async function(scope, deps) {
+    throw new Error(`No storage implementation for post. Install a storage plugin.`);
+  },
+
+  dataPatch: async function(scope, deps) {
+    throw new Error(`No storage implementation for patch. Install a storage plugin.`);
+  },
+  
+  dataPut: async function(scope, deps) {
+    throw new Error(`No storage implementation for put. Install a storage plugin.`);
+  },
+  
+  dataDelete: async function(scope, deps) {
+    throw new Error(`No storage implementation for delete. Install a storage plugin.`);
+  }
+};

package/plugins/core/{utils → lib/querying-writing}/field-utils.js

@@ -1,45 +1,55 @@
 /**
- * @module field-utils
- * @description Pure utility functions for field and schema manipulation
+ * Extracts all foreign key fields from a schema definition
  * 
- * This module contains pure functions extracted from knex-field-helpers.js
- * that don't require scope context or dependencies. These functions can be
- * used independently for schema inspection and field filtering.
- */
-
-/**
- * Extracts all foreign key fields from a schema definition.
- * 
- * This function identifies fields that represent foreign keys based on belongsTo
- * relationships in the schema. These fields need special handling because they're
- * stored in the database but not exposed as attributes in JSON:API responses.
- * Instead, they're represented as relationships.
- * 
- * @param {Object} schema - The schema definition (can be Schema object or plain object)
+ * @param {Object} schema - The schema definition (Schema object or plain object)
  * @returns {Set<string>} Set of foreign key field names
  * 
- * @example <caption>Basic foreign key extraction</caption>
+ * @example
+ * // Input: Schema with belongsTo relationships
  * const schema = {
  *   title: { type: 'string' },
+ *   content: { type: 'string' },
  *   author_id: { type: 'number', belongsTo: 'users', as: 'author' },
- *   category_id: { type: 'number', belongsTo: 'categories', as: 'category' }
+ *   category_id: { type: 'number', belongsTo: 'categories', as: 'category' },
+ *   status: { type: 'string' }
  * };
+ * 
  * const foreignKeys = getForeignKeyFields(schema);
- * // Returns Set(['author_id', 'category_id'])
  * 
- * @example <caption>Schema object vs plain object</caption>
- * // Works with both compiled Schema objects and plain schema definitions
- * const schemaObject = createSchema(schema);
- * const foreignKeys1 = getForeignKeyFields(schemaObject); // Schema object
- * const foreignKeys2 = getForeignKeyFields(schema);       // Plain object
- * // Both return the same Set
+ * // Output: Set containing only foreign key fields
+ * // Set(['author_id', 'category_id'])
+ * 
+ * @example
+ * // Input: Works with compiled Schema objects too
+ * const schemaObject = {
+ *   structure: {
+ *     post_id: { type: 'id', belongsTo: 'posts', as: 'post' },
+ *     user_id: { type: 'id', belongsTo: 'users', as: 'user' }
+ *   }
+ * };
+ * 
+ * const foreignKeys = getForeignKeyFields(schemaObject);
+ * 
+ * // Output: Handles both formats
+ * // Set(['post_id', 'user_id'])
+ * 
+ * @description
+ * Used by:
+ * - toJsonApi to filter foreign keys from attributes
+ * - buildFieldSelection to ensure foreign keys are always selected
+ * - knex-json-api-helpers for field filtering
+ * 
+ * Purpose:
+ * - Identifies fields that should be relationships, not attributes
+ * - Foreign keys are stored in DB but not exposed as JSON:API attributes
+ * - Ensures these fields are included in SELECT for relationship building
+ * - Helps transform database structure to JSON:API format
  * 
- * @example <caption>Why this is useful upstream</caption>
- * // The REST API Knex plugin uses this to:
- * // 1. Filter out foreign keys when building JSON:API attributes
- * // 2. Include foreign keys in SELECT even with sparse fieldsets
- * // 3. Identify which fields need relationship transformation
- * // 4. Optimize queries by knowing which fields are joins
+ * Data flow:
+ * 1. Accepts schema in either format (plain or with structure property)
+ * 2. Iterates through all field definitions
+ * 3. Collects fields with belongsTo property
+ * 4. Returns Set for efficient lookups
  */
 export const getForeignKeyFields = (schema) => {
   const foreignKeys = new Set();

package/plugins/core/{utils → lib/querying-writing}/knex-constants.js

@@ -10,6 +10,7 @@
 export const RELATIONSHIPS_KEY = '__$jsonrestapi_relationships$__';
 export const RELATIONSHIP_METADATA_KEY = '__$jsonrestapi_metadata$__';
 export const ROW_NUMBER_KEY = '__$jsonrestapi_rn$__';
+export const COMPUTED_DEPENDENCIES_KEY = '__$jsonrestapi_computed_deps$__';
 
 // Default query limits
 export const DEFAULT_QUERY_LIMIT = 20;

package/plugins/core/lib/{knex-field-helpers.js → querying-writing/knex-field-helpers.js}

@@ -1,79 +1,151 @@
 /**
- * @module knex-field-helpers
- * @description Context-dependent field helpers for Knex operations
+ * Checks if a field exists only in code, not in the database
  * 
- * This module contains field helper functions that require scope context and
- * dependencies. Pure utility functions have been moved to utils/field-utils.js.
- */
-
-import { getForeignKeyFields, filterHiddenFields } from '../utils/field-utils.js';
-
-// Re-export pure utility functions from field-utils
-export { getForeignKeyFields, filterHiddenFields } from '../utils/field-utils.js';
-
-/**
- * Helper function to check if a field should be excluded from database operations
  * @param {string} fieldName - The field name to check
- * @param {Object} schemaInfo - The schema info object containing computed and virtual fields
- * @returns {boolean} True if the field is non-database (computed or virtual)
+ * @param {Object} schemaInfo - Schema info with computed fields and structure
+ * @returns {boolean} True if field is computed or virtual
+ * 
+ * @example
+ * // Input: Check computed field
+ * const schemaInfo = {
+ *   computed: { profit_margin: { (definition) } },
+ *   schemaStructure: { price: { type: 'number' } }
+ * };
+ * isNonDatabaseField('profit_margin', schemaInfo);
+ * // Output: true (it's computed, not stored)
+ * 
+ * @example
+ * // Input: Check virtual field
+ * const schemaInfo = {
+ *   computed: {},
+ *   schemaStructure: { 
+ *     temp_password: { type: 'string', virtual: true }
+ *   }
+ * };
+ * isNonDatabaseField('temp_password', schemaInfo);
+ * // Output: true (it's virtual, not stored)
+ * 
+ * @description
+ * Used by:
+ * - buildFieldSelection to exclude from SELECT queries
+ * - dataPost/dataPatch to skip non-database fields
+ * - enrichAttributes to identify computed fields
+ * 
+ * Purpose:
+ * - Prevents SQL errors by excluding non-existent columns
+ * - Identifies fields that need computation or special handling
+ * - Supports virtual fields for temporary/input-only data
  */
 export const isNonDatabaseField = (fieldName, schemaInfo) => {
-  const { computed = {}, virtual = {} } = schemaInfo;
-  return fieldName in computed || fieldName in virtual;
+  const { computed = {}, schemaStructure = {} } = schemaInfo;
+  if (fieldName in computed) return true;
+  const fieldDef = schemaStructure[fieldName];
+  return fieldDef && fieldDef.virtual === true;
 };
 
 /**
- * Builds the field selection list for database queries, handling sparse fieldsets.
- * 
- * This function constructs the SELECT clause fields based on JSON:API sparse fieldsets
- * while ensuring all necessary fields are included for proper relationship handling.
- * It always includes ID and foreign key fields even if not explicitly requested,
- * because these are needed for JSON:API relationship links.
+ * Builds the field selection list for database queries with sparse fieldset support
  * 
- * @param {Object} scope - The scope object containing schema and configuration
+ * @param {Object} scope - Resource scope with schema information
  * @param {Object} deps - Dependencies object
- * @param {Object} deps.context - Request context containing queryParams and schemaInfo
- * @returns {Promise<Object>} Object with fieldsToSelect, requestedFields, and computedDependencies
+ * @param {Object} deps.context - Request context with queryParams and schemaInfo
+ * @returns {Promise<Object>} Field selection information
  * 
- * @example <caption>Sparse fieldset with automatic foreign key inclusion</caption>
- * const scope = api.resources['articles'];
+ * @example
+ * // Input: Basic sparse fieldset request
  * const deps = {
  *   context: {
  *     scopeName: 'articles',
  *     queryParams: { fields: { articles: 'title,body' } },
- *     schemaInfo: scope.vars.schemaInfo
+ *     schemaInfo: { idProperty: 'id', ...  }
  *   }
  * };
- * const fieldInfo = await buildFieldSelection(scope, deps);
- * // Returns {
+ * const result = await buildFieldSelection(scope, deps);
+ * 
+ * // Output: Includes requested fields plus required fields
+ * // {
  * //   fieldsToSelect: ['id', 'title', 'body', 'author_id', 'category_id'],
  * //   requestedFields: ['title', 'body'],
- * //   computedDependencies: []
+ * //   computedDependencies: [],
+ * //   idProperty: 'id'
  * // }
+ * // Note: Foreign keys (author_id, category_id) always included for relationships
  * 
- * @example <caption>With computed fields and dependencies</caption>
+ * @example
+ * // Input: Computed field with hidden dependencies
+ * const schemaInfo = {
+ *   computed: {
+ *     profit_margin: { 
+ *       compute: (record) => (record.price - record.cost) / record.price,
+ *       dependencies: ['price', 'cost']
+ *     }
+ *   },
+ *   schemaStructure: {
+ *     name: { type: 'string' },
+ *     price: { type: 'number' },
+ *     cost: { type: 'number', normallyHidden: true }
+ *   }
+ * };
  * const deps = {
  *   context: {
- *     scopeName: 'products',
- *     queryParams: { fields: { products: 'name,profit_margin' } },
- *     schemaInfo: scope.vars.schemaInfo
+ *     queryParams: { fields: { products: 'name,profit_margin' } }
  *   }
  * };
- * const fieldInfo = await buildFieldSelection(scope, deps);
- * // Returns {
- * //   fieldsToSelect: ['id', 'name', 'price', 'cost'], // cost needed for profit_margin
+ * 
+ * // Output: Fetches hidden dependency for computation
+ * // {
+ * //   fieldsToSelect: ['id', 'name', 'price', 'cost'],
  * //   requestedFields: ['name', 'profit_margin'],
- * //   computedDependencies: ['cost'] // will be removed from final response
+ * //   computedDependencies: ['cost'], // Will be removed after computation
+ * //   idProperty: 'id'
+ * // }
+ * 
+ * @example
+ * // Input: No sparse fieldsets (returns all visible fields)
+ * const deps = {
+ *   context: {
+ *     queryParams: {}, // No fields parameter
+ *     schemaInfo: { ... }
+ *   }
+ * };
+ * 
+ * // Output: All non-hidden, non-virtual fields
+ * // {
+ * //   fieldsToSelect: ['id', 'title', 'body', 'published_at', 'author_id'],
+ * //   requestedFields: null,
+ * //   computedDependencies: [],
+ * //   idProperty: 'id'
  * // }
+ * 
+ * @description
+ * Used by:
+ * - dataGet to build SELECT query
+ * - dataQuery to build SELECT query  
+ * - buildQuerySelection as the main field resolver
+ * 
+ * Purpose:
+ * - Implements JSON:API sparse fieldsets specification
+ * - Ensures relationships work by including foreign keys
+ * - Handles computed field dependencies intelligently
+ * - Respects field visibility rules (hidden/normallyHidden)
+ * - Supports custom ID column names
+ * 
+ * Data flow:
+ * 1. Always includes ID (with aliasing if needed)
+ * 2. Parses requested fields from query string
+ * 3. Validates requested fields exist in schema
+ * 4. Adds dependencies for computed fields
+ * 5. Includes all foreign keys for relationships
+ * 6. Returns complete field list for SQL SELECT
  */
 export const buildFieldSelection = async (scope, deps) => {
   let fieldsToSelect = new Set();
   let computedDependencies = new Set();
-  
+
   // Extract values from scope
   const { 
     vars: { 
-      schemaInfo: { schema, computed: computedFields = {}, virtual: virtualFields = {} }
+      schemaInfo: { schema, computed: computedFields = {}, schemaStructure }
     }
   } = scope;
   
@@ -84,17 +156,30 @@ export const buildFieldSelection = async (scope, deps) => {
   const idProperty = context.schemaInfo.idProperty;
   
   // Always include the ID field - required for JSON:API
-  fieldsToSelect.add(idProperty);
+  // Handle aliasing if idProperty is not 'id'
+  if (idProperty !== 'id') {
+    fieldsToSelect.add(`${idProperty} as id`);
+  } else {
+    fieldsToSelect.add('id');
+  }
   
-  // Get computed and virtual fields - these are not stored in the database
-  // Computed: { profit_margin: { type: 'number', dependencies: ['price', 'cost'], compute: ... } }
-  // Virtual: { passwordConfirmation: { type: 'string' } }
+  // Handle both Schema objects and plain objects
+  if (!schemaStructure) {
+    schemaStructure = schema?.structure || schema || {};
+  }
+  
+  // Get computed fields and virtual fields from schema
   const computedFieldNames = new Set(Object.keys(computedFields));
-  const virtualFieldNames = new Set(Object.keys(virtualFields));
-  const nonDatabaseFields = new Set([...computedFieldNames, ...virtualFieldNames]);
   
-  // Handle both Schema objects and plain objects
-  const schemaStructure = schema?.structure || schema || {};
+  // Find fields marked as virtual in the schema
+  const virtualFieldNames = new Set();
+  Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
+    if (fieldDef.virtual === true) {
+      virtualFieldNames.add(fieldName);
+    }
+  });
+  
+  const nonDatabaseFields = new Set([...computedFieldNames, ...virtualFieldNames]);
   
   // Parse requested fields
   const requested = requestedFields ? (
@@ -113,7 +198,7 @@ export const buildFieldSelection = async (scope, deps) => {
       if (nonDatabaseFields.has(field)) return;
       
       const fieldDef = schemaStructure[field];
-      if (!fieldDef) return; // Unknown field, skip
+      if (!fieldDef) throw new Error(`Unknown sparse field '${field}' requested for '${scopeName}'`);
       
       // NEVER include hidden fields, even if explicitly requested
       // Example: password_hash with hidden:true is never returned
@@ -162,6 +247,9 @@ export const buildFieldSelection = async (scope, deps) => {
     // No sparse fieldsets - return all visible fields
     // This is the default behavior when no ?fields parameter is provided
     Object.entries(schemaStructure).forEach(([field, fieldDef]) => {
+      // Skip virtual fields - they don't exist in database
+      if (fieldDef.virtual === true) return;
+      
       // Skip hidden fields - these are NEVER returned
       // Example: password_hash with hidden:true
       if (fieldDef.hidden === true) return;
@@ -222,17 +310,62 @@ export const buildFieldSelection = async (scope, deps) => {
   return {
     fieldsToSelect: Array.from(fieldsToSelect),      // Fields to SELECT from database
     requestedFields: requested,                       // Fields explicitly requested by user
-    computedDependencies: Array.from(computedDependencies)  // Dependencies to remove from response
+    computedDependencies: Array.from(computedDependencies),  // Dependencies to remove from response
+    idProperty                                        // Pass idProperty for reference
   };
 };
 
 /**
- * Gets the list of requested computed fields based on sparse fieldsets.
+ * Determines which computed fields to calculate based on sparse fieldsets
+ * 
+ * @param {string} scopeName - Resource name (e.g., 'products')
+ * @param {Array<string>|string} requestedFields - Requested fields from query
+ * @param {Object} computedFields - Computed field definitions from schema
+ * @returns {Array<string>} Names of computed fields to calculate
+ * 
+ * @example
+ * // Input: No sparse fieldsets (calculate all computed fields)
+ * const computed = {
+ *   full_name: { compute: (r) => `${r.first} ${r.last}` },
+ *   age: { compute: (r) => new Date().getFullYear() - r.birth_year }
+ * };
+ * getRequestedComputedFields('users', null, computed);
+ * // Output: ['full_name', 'age'] (all computed fields)
+ * 
+ * @example
+ * // Input: Sparse fieldsets with some computed fields
+ * const requestedFields = 'first_name,full_name,email';
+ * const computed = {
+ *   full_name: { compute: (r) => `${r.first} ${r.last}` },
+ *   age: { compute: (r) => new Date().getFullYear() - r.birth_year }
+ * };
+ * getRequestedComputedFields('users', requestedFields, computed);
+ * // Output: ['full_name'] (only requested computed field)
+ * 
+ * @example
+ * // Input: Sparse fieldsets with no computed fields
+ * const requestedFields = ['first_name', 'email'];
+ * const computed = {
+ *   full_name: { compute: (r) => `${r.first} ${r.last}` }
+ * };
+ * getRequestedComputedFields('users', requestedFields, computed);
+ * // Output: [] (no computed fields requested)
+ * 
+ * @description
+ * Used by:
+ * - enrichAttributes to determine which computations to run
+ * - Applied after fetching data from database
+ * 
+ * Purpose:
+ * - Optimizes performance by only computing requested fields
+ * - Supports JSON:API sparse fieldsets for computed fields
+ * - Handles both string and array input formats
  * 
- * @param {string} scopeName - The name of the scope/resource
- * @param {Array<string>|string} requestedFields - Array or comma-separated string of requested fields
- * @param {Object} computedFields - Object containing computed field definitions
- * @returns {Array<string>} Array of computed field names to calculate
+ * Data flow:
+ * 1. Checks if sparse fieldsets are specified
+ * 2. If not, returns all computed field names
+ * 3. If yes, filters to only requested computed fields
+ * 4. Normalizes string input to array format
  */
 export const getRequestedComputedFields = (scopeName, requestedFields, computedFields) => {
   if (!computedFields) return [];

package/plugins/core/lib/querying-writing/knex-json-api-transformers.js

@@ -0,0 +1,162 @@
+import { toJsonApiRecord } from '../querying/knex-json-api-transformers-querying.js';
+import { getSchemaStructure } from './knex-constants.js';
+
+/**
+ * Converts database record to JSON:API format with belongsTo relationships
+ * 
+ * @param {Object} scope - Resource scope with schema and relationship info
+ * @param {Object} record - Raw database record
+ * @param {string} scopeName - Resource type name
+ * @returns {Object} JSON:API resource with belongsTo relationships
+ * 
+ * @example
+ * // Input: Database record with foreign keys
+ * const dbRecord = {
+ *   id: 1,
+ *   title: 'Hello World',
+ *   author_id: 2,
+ *   publisher_id: 3,
+ *   category_id: null
+ * };
+ * const result = toJsonApiRecordWithBelongsTo(scope, dbRecord, 'articles');
+ * 
+ * // Output: JSON:API with relationship objects
+ * // {
+ * //   type: 'articles',
+ * //   id: '1',
+ * //   attributes: {
+ * //     title: 'Hello World'
+ * //     // Note: author_id, publisher_id, category_id removed
+ * //   },
+ * //   relationships: {
+ * //     author: {
+ * //       data: { type: 'authors', id: '2' }
+ * //     },
+ * //     publisher: {
+ * //       data: { type: 'publishers', id: '3' }
+ * //     },
+ * //     category: {
+ * //       data: null  // Explicit null for empty relationship
+ * //     }
+ * //   }
+ * // }
+ * 
+ * @example
+ * // Input: Polymorphic relationships
+ * const dbRecord = {
+ *   id: 5,
+ *   content: 'Great post!',
+ *   commentable_type: 'articles',
+ *   commentable_id: 10
+ * };
+ * // With schema defining polymorphic relationship:
+ * // relationships: {
+ * //   commentable: {
+ * //     belongsToPolymorphic: true,
+ * //     typeField: 'commentable_type',
+ * //     idField: 'commentable_id'
+ * //   }
+ * // }
+ * 
+ * // Output: Polymorphic relationship in JSON:API
+ * // {
+ * //   type: 'comments',
+ * //   id: '5',
+ * //   attributes: { content: 'Great post!' },
+ * //   relationships: {
+ * //     commentable: {
+ * //       data: { type: 'articles', id: '10' }
+ * //     }
+ * //   }
+ * // }
+ * 
+ * @description
+ * Used by:
+ * - dataGetMinimal for lightweight single record fetches
+ * - dataDelete to return deleted record structure
+ * - Internal operations needing quick JSON:API conversion
+ * 
+ * Purpose:
+ * - Provides JSON:API structure without loading related data
+ * - Transforms foreign keys into relationship objects
+ * - Handles both regular and polymorphic belongsTo
+ * - Maintains explicit nulls for empty relationships
+ * 
+ * Data flow:
+ * 1. Calls toJsonApiRecord for basic transformation
+ * 2. Scans schema for belongsTo field definitions
+ * 3. Converts foreign key values to relationship objects
+ * 4. Processes polymorphic relationships separately
+ * 5. Returns complete JSON:API resource object
+ */
+export const toJsonApiRecordWithBelongsTo = (scope, record, scopeName) => {
+  if (!record) return null;
+  
+  // Get the basic JSON:API structure (without relationships)
+  const jsonApiRecord = toJsonApiRecord(scope, record, scopeName);
+  
+  // Extract schema info from scope
+  const { 
+    vars: { 
+      schemaInfo: { schema, schemaRelationships: relationships, idProperty }
+    }
+  } = scope;
+  
+  const idField = idProperty || 'id';
+  
+  // Get schema structure
+  const schemaStructure = getSchemaStructure(schema);
+  
+  // Initialize relationships object
+  jsonApiRecord.relationships = {};
+  
+  // Process regular belongsTo relationships from schema
+  for (const [fieldName, fieldDef] of Object.entries(schemaStructure)) {
+    if (fieldDef.belongsTo && fieldDef.as) {
+      const foreignKeyValue = record[fieldName];
+      
+      if (foreignKeyValue !== null && foreignKeyValue !== undefined) {
+        jsonApiRecord.relationships[fieldDef.as] = {
+          data: {
+            type: fieldDef.belongsTo,
+            id: String(foreignKeyValue)
+          }
+        };
+      } else {
+        // Explicitly null relationship
+        jsonApiRecord.relationships[fieldDef.as] = {
+          data: null
+        };
+      }
+    }
+  }
+  
+  // Process polymorphic belongsTo relationships
+  Object.entries(relationships || {}).forEach(([relName, relDef]) => {
+    if (relDef.belongsToPolymorphic) {
+      const typeValue = record[relDef.typeField];
+      const idValue = record[relDef.idField];
+      
+      if (typeValue && idValue) {
+        jsonApiRecord.relationships[relName] = {
+          data: {
+            type: typeValue,
+            id: String(idValue)
+          }
+        };
+      } else {
+        // Explicitly null relationship
+        jsonApiRecord.relationships[relName] = {
+          data: null
+        };
+      }
+    }
+  });
+  
+  // Remove relationships object if empty
+  if (Object.keys(jsonApiRecord.relationships).length === 0) {
+    delete jsonApiRecord.relationships;
+  }
+  
+  return jsonApiRecord;
+};