json-rest-api 1.0.10 → 1.0.13

package/plugins/core/lib/querying-writing/simplified-helpers.js

@@ -48,7 +48,7 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * // }
  * 
  * @example
- * // Input: Object with foreign key (traditional way)
+ * // Input: Object with relationship name (preferred way)
  * const schema = {
  *   title: { type: 'string' },
  *   author_id: { 
@@ -60,19 +60,19 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * const input = {
  *   id: '456',
  *   title: 'Another Article',
- *   author_id: 789                      // Using foreign key name
+ *   author: 789                         // Using relationship name
  * };
  * 
- * // Output: Foreign key becomes relationship
+ * // Output: Relationship becomes JSON:API relationship
  * // {
  * //   data: {
  * //     type: 'articles',
  * //     id: '456',
  * //     attributes: {
- * //       title: 'Another Article'       // author_id removed
+ * //       title: 'Another Article'       // author removed from attributes
  * //     },
  * //     relationships: {
- * //       author: {                      // Uses 'as' name
+ * //       author: {                      
  * //         data: { type: 'users', id: '789' }
  * //       }
  * //     }
@@ -80,11 +80,11 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * // }
  *
  * @example
- * // Input: Object with relationship alias (preferred way)
+ * // Input: Object with relationship name (only supported way)
  * const input = {
  *   id: '456',
  *   title: 'Another Article',
- *   author: 789                         // Using 'as' alias directly
+ *   author: 789                         // Using relationship name
  * };
  * // Output: Same JSON:API structure as above
  *
@@ -92,12 +92,11 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * // Input: Many-to-many relationship
  * const relationships = {
  *   tags: {
- *     manyToMany: {
- *       through: 'article_tags',
- *       foreignKey: 'article_id',
- *       otherKey: 'tag_id',
- *       otherType: 'tags'
- *     }
+ *     type: 'manyToMany',
+ *     through: 'article_tags',
+ *     foreignKey: 'article_id',
+ *     otherKey: 'tag_id',
+ *     target: 'tags'
  *   }
  * };
  * const input = {
@@ -134,6 +133,57 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  *   }
  * };
  * // Output: Returned unchanged (detected by data.type)
+ *
+ * @example
+ * // Input: Polymorphic relationship with minimal object format
+ * const relationships = {
+ *   commentable: {
+ *     belongsToPolymorphic: {
+ *       types: ['posts', 'videos'],
+ *       typeField: 'commentable_type',
+ *       idField: 'commentable_id'
+ *     }
+ *   }
+ * };
+ * const input = {
+ *   text: 'Great content!',
+ *   commentable: { id: '456', _type: 'posts' }  // Minimal object format
+ * };
+ * 
+ * // Output: Proper JSON:API structure for polymorphic
+ * // {
+ * //   data: {
+ * //     type: 'comments',
+ * //     attributes: {
+ * //       text: 'Great content!'
+ * //     },
+ * //     relationships: {
+ * //       commentable: {
+ * //         data: { type: 'posts', id: '456' }
+ * //       }
+ * //     }
+ * //   }
+ * // }
+ *
+ * @example
+ * // Input: Clearing polymorphic relationship
+ * const input = {
+ *   text: 'Updated comment',
+ *   commentable: null  // Clear the relationship
+ * };
+ * 
+ * // Output: Relationship set to null
+ * // {
+ * //   data: {
+ * //     type: 'comments',
+ * //     attributes: {
+ * //       text: 'Updated comment'
+ * //     },
+ * //     relationships: {
+ * //       commentable: { data: null }
+ * //     }
+ * //   }
+ * // }
  * 
  * @description
  * Used by:
@@ -143,7 +193,8 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * Purpose:
  * - Provides developer-friendly plain object API
  * - Automatically detects and converts relationships
- * - Supports both foreign key and alias notation
+ * - Supports relationship alias notation
+ * - Supports polymorphic relationships with minimal object format
  * - Maintains JSON:API compliance internally
  * - Allows gradual migration from simple to JSON:API
  * 
@@ -152,7 +203,8 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * 2. Extracts ID from input object
  * 3. Processes belongsTo relationships from schema
  * 4. Processes hasMany/manyToMany from relationships
- * 5. Remaining fields become attributes
+ * 5. Processes polymorphic belongsTo from relationships
+ * 6. Remaining fields become attributes
  * 6. Builds proper JSON:API document structure
  */
 export const transformSimplifiedToJsonApi = (scope, deps) => {
@@ -181,31 +233,27 @@ export const transformSimplifiedToJsonApi = (scope, deps) => {
       const relAlias = fieldDef.as || fieldName; // Use 'as' alias or foreign key name as default alias
       let valueToProcess = undefined;
 
-      // Check if both foreign key and alias are provided - this is an error
-      if (fieldDef.as && tempInput[fieldName] !== undefined && tempInput[fieldDef.as] !== undefined) {
+      // Check if the user provided the foreign key name (e.g., country_id) - NO LONGER ALLOWED
+      if (tempInput[fieldName] !== undefined) {
         throw new RestApiValidationError(
-          `Cannot specify both '${fieldName}' and '${fieldDef.as}' for the same relationship. ` +
-          `Use either '${fieldName}' (foreign key) or '${fieldDef.as}' (relationship name), not both.`,
+          `Foreign key field '${fieldName}' is no longer supported for relationship input. ` +
+          `Use the relationship name '${fieldDef.as || fieldName}' instead.`,
           {
-            fields: [fieldName, fieldDef.as],
+            fields: [fieldName],
             violations: [{
-              field: 'input',
-              rule: 'duplicate_relationship_specification',
-              message: `Both '${fieldName}' and '${fieldDef.as}' were provided for the same relationship`
+              field: fieldName,
+              rule: 'deprecated_foreign_key',
+              message: `Use relationship name instead of foreign key field`
             }]
           }
         );
       }
-
-      // Check if the user provided the foreign key name (e.g., country_id)
-      if (tempInput[fieldName] !== undefined) {
-        valueToProcess = tempInput[fieldName];
-        delete tempInput[fieldName]; // Remove from tempInput once processed
-      }
-      // Check if the user provided the 'as' alias (e.g., country)
-      else if (fieldDef.as && tempInput[fieldDef.as] !== undefined) {
-        valueToProcess = tempInput[fieldDef.as];
-        delete tempInput[fieldDef.as]; // Remove from tempInput once processed
+      
+      // Check if the user provided the relationship name (e.g., country)
+      const relName = fieldDef.as || fieldName;
+      if (tempInput[relName] !== undefined) {
+        valueToProcess = tempInput[relName];
+        delete tempInput[relName]; // Remove from tempInput once processed
       }
 
       if (valueToProcess !== undefined) {
@@ -224,12 +272,21 @@ export const transformSimplifiedToJsonApi = (scope, deps) => {
       const value = tempInput[relName];
       delete tempInput[relName]; // Remove from tempInput once processed
 
-      if ((relConfig.hasMany || relConfig.manyToMany) && Array.isArray(value)) {
-        const targetType = relConfig.hasMany || relConfig.manyToMany?.otherType || relConfig.through;
+      if ((relConfig.type === 'hasMany' || relConfig.type === 'manyToMany') && Array.isArray(value)) {
+        // Determine the target type based on relationship type:
+        // - For manyToMany: the targetType is the relationship name itself
+        // - For hasMany/hasOne: the targetType is specified in the target property
+        const targetType = relConfig.type === 'manyToMany' ? relName : relConfig.target;
         relationshipsData[relName] = {
           data: value.map(relId => ({ type: targetType, id: String(relId) }))
         };
       }
+      // Handle hasOne relationships
+      else if (relConfig.type === 'hasOne' && value !== undefined) {
+        relationshipsData[relName] = {
+          data: value ? { type: relConfig.target, id: String(value) } : null
+        };
+      }
       // Handle single belongsTo relationships if they were also defined in 'relationships'
       // (though typically they are defined in schema.belongsTo)
       else if (relConfig.belongsTo && value !== undefined) {
@@ -237,6 +294,28 @@ export const transformSimplifiedToJsonApi = (scope, deps) => {
               data: value ? { type: relConfig.belongsTo, id: String(value) } : null
           };
       }
+      // Handle polymorphic belongsTo relationships with minimal object format
+      else if (relConfig.belongsToPolymorphic && value !== undefined) {
+        if (value === null) {
+          relationshipsData[relName] = { data: null };
+        } else if (typeof value === 'object' && value !== null && value.id && value._type) {
+          relationshipsData[relName] = {
+            data: { type: value._type, id: String(value.id) }
+          };
+        } else {
+          throw new RestApiValidationError(
+            `Invalid format for polymorphic relationship '${relName}'. Expected { id: 'value', _type: 'type' } or null`,
+            {
+              fields: [relName],
+              violations: [{
+                field: relName,
+                rule: 'polymorphic_format',
+                message: 'Must be an object with id and _type properties, or null'
+              }]
+            }
+          );
+        }
+      }
     }
   }
 
@@ -390,7 +469,7 @@ export const transformSimplifiedToJsonApi = (scope, deps) => {
  * //     id: '75',
  * //     name: 'Jane Smith'
  * //   },
- * //   chapters_ids: ['1001', '1002'],
+ * //   chapters: [{ id: '1001' }, { id: '1002' }],
  * //   chapters: [                  // Expanded array
  * //     { id: '1001', number: 1, title: 'Introduction' },
  * //     { id: '1002', number: 2, title: 'Basics' }
@@ -404,7 +483,7 @@ export const transformSimplifiedToJsonApi = (scope, deps) => {
  * 
  * Purpose:
  * - Provides cleaner response format for clients
- * - Restores foreign keys from relationships
+ * - Creates minimal relationship objects from relationships
  * - Expands included resources for convenience
  * - Maintains compatibility with collection metadata
  * - Handles both single and array responses
@@ -497,13 +576,13 @@ export const transformJsonApiToSimplified = (scope, deps) => {
  *   { context: { schemaStructure: schema } }
  * );
  * 
- * // Output: Flattened with foreign keys restored
+ * // Output: Minimal relationship objects
  * // {
  * //   id: '100',
  * //   text: 'Great article!',
  * //   created_at: '2024-01-15',
- * //   author_id: '50',          // From relationships.author
- * //   article_id: '200'         // From relationships.article
+ * //   author: { id: '50' },          // Minimal object from relationships.author
+ * //   article: { id: '200' }         // Minimal object from relationships.article
  * // }
  * 
  * @example
@@ -526,11 +605,73 @@ export const transformJsonApiToSimplified = (scope, deps) => {
  *   tags: { manyToMany: { via: 'article_tags' } }
  * };
  * 
- * // Output: Array of IDs with _ids suffix
+ * // Output: Minimal relationship objects
  * // {
  * //   id: '300',
  * //   title: 'My Article',
- * //   tags_ids: ['1', '2', '3']   // Relationship name + _ids
+ * //   tags: [{ id: '1' }, { id: '2' }, { id: '3' }]   // Minimal objects
+ * // }
+ * 
+ * @example
+ * // Input: Polymorphic relationship
+ * const data = {
+ *   type: 'reviews',
+ *   id: '500',
+ *   attributes: { rating: 5, comment: 'Great!' },
+ *   relationships: {
+ *     reviewable: {
+ *       data: { type: 'authors', id: '75' }
+ *     }
+ *   }
+ * };
+ * const relationships = {
+ *   reviewable: {
+ *     belongsToPolymorphic: {
+ *       types: ['authors', 'publishers'],
+ *       typeField: 'reviewable_type',
+ *       idField: 'reviewable_id'
+ *     }
+ *   }
+ * };
+ * 
+ * // Output: Minimal polymorphic object with type
+ * // {
+ * //   id: '500',
+ * //   rating: 5,
+ * //   comment: 'Great!',
+ * //   reviewable: { id: '75', type: 'authors' }   // Minimal object with type
+ * // }
+ * 
+ * @example
+ * // Input: Polymorphic relationship with included resource
+ * const dataWithInclude = {
+ *   type: 'reviews',
+ *   id: '500',
+ *   attributes: { rating: 5, comment: 'Great!' },
+ *   relationships: {
+ *     reviewable: {
+ *       data: { type: 'authors', id: '75' }
+ *     }
+ *   }
+ * };
+ * const included = [
+ *   {
+ *     type: 'authors',
+ *     id: '75',
+ *     attributes: { name: 'Jane Smith', bio: 'Fantastic author' }
+ *   }
+ * ];
+ * 
+ * // Output: Full polymorphic object (type field removed as redundant)
+ * // {
+ * //   id: '500',
+ * //   rating: 5,
+ * //   comment: 'Great!',
+ * //   reviewable: {                // Full object when included
+ * //     id: '75',
+ * //     name: 'Jane Smith',
+ * //     bio: 'Fantastic author'
+ * //   }
  * // }
  * 
  * @example
@@ -574,17 +715,15 @@ export const transformJsonApiToSimplified = (scope, deps) => {
  *   }
  * ];
  * 
- * // Output: Recursively expanded (note author.company_id)
+ * // Output: Recursively expanded
  * // {
  * //   id: '400',
  * //   title: 'JavaScript Guide',
- * //   author_id: '75',
  * //   author: {                    // Expanded and transformed
  * //     id: '75',
  * //     name: 'Jane Smith',
- * //     company_id: '5'            // Author's relationships processed!
+ * //     company: { id: '5' }       // Author's relationships processed as minimal objects!
  * //   },
- * //   chapters_ids: ['1001', '1002'],
  * //   chapters: [
  * //     { id: '1001', number: 1, title: 'Introduction' },
  * //     { id: '1002', number: 2, title: 'Basics' }
@@ -598,17 +737,17 @@ export const transformJsonApiToSimplified = (scope, deps) => {
  * 
  * Purpose:
  * - Core transformation logic for single resources
- * - Restores foreign keys from relationships
- * - Creates _ids arrays for to-many relationships
+ * - Creates minimal relationship objects from relationships
+ * - Creates arrays of minimal relationship objects for to-many relationships
  * - Recursively expands and transforms included data
  * - Handles polymorphic relationships
  * 
  * Data flow:
  * 1. Copies ID and attributes to result
  * 2. Processes each relationship:
- *    - BelongsTo: restores foreign key field
- *    - Polymorphic: restores type and ID fields
- *    - HasMany/ManyToMany: creates _ids array
+ *    - BelongsTo: creates minimal relationship object
+ *    - Polymorphic: creates minimal relationship object with type
+ *    - HasMany/ManyToMany: creates array of minimal relationship objects
  * 3. If included data exists:
  *    - Finds matching included resources
  *    - Recursively transforms them (preserving their relationships!)
@@ -634,7 +773,7 @@ export const transformSingleJsonApiToSimplified = (scope, deps) => {
   // Add attributes
   Object.assign(simplified, data.attributes || {});
 
-  // Extract foreign keys from relationships
+  // Process relationships to create minimal objects
   if (data.relationships) {
     for (const [relName, relData] of Object.entries(data.relationships)) {
       // Find schema field for this belongsTo relationship
@@ -643,23 +782,22 @@ export const transformSingleJsonApiToSimplified = (scope, deps) => {
       if (schemaEntry) {
         const [fieldName, fieldDef] = schemaEntry;
         if (fieldDef.belongsTo && relData.data) {
-          simplified[fieldName] = relData.data.id;
+          // Create minimal relationship object (no more foreign key field)
+          simplified[relName] = { id: relData.data.id };
         }
       }
 
       // Check if this is a polymorphic relationship from the relationships config
       const rel = relationships?.[relName];
       if (rel?.belongsToPolymorphic && relData.data) {
-        // For polymorphic relationships, restore both the type and id fields
-        const { typeField, idField } = rel.belongsToPolymorphic;
-        simplified[typeField] = relData.data.type;
-        simplified[idField] = relData.data.id;
+        // Create minimal relationship object for polymorphic (no more type/id fields)
+        simplified[relName] = { id: relData.data.id, _type: relData.data.type };
       }
 
-      // Handle many-to-many (just IDs, not nested)
-      if (rel?.hasMany || rel?.manyToMany) {
+      // Handle to-many relationships (create minimal objects with just IDs)
+      if (rel?.type === 'hasMany' || rel?.type === 'manyToMany') {
         if (relData.data && Array.isArray(relData.data)) {
-          simplified[`${relName}_ids`] = relData.data.map(item => item.id);
+          simplified[relName] = relData.data.map(item => ({ id: item.id }));
         }
       }
 
@@ -681,6 +819,10 @@ export const transformSingleJsonApiToSimplified = (scope, deps) => {
                   scopes
                 } }
               );
+              // For polymorphic relationships, add _type field to identify the resource type
+              if (rel?.belongsToPolymorphic) {
+                itemSimplified._type = item.type;
+              }
               return itemSimplified;
             });
           }
@@ -688,7 +830,7 @@ export const transformSingleJsonApiToSimplified = (scope, deps) => {
           const nestedData = findIncluded(relData.data);
           if (nestedData) {
             // Transform the single included record to restore its relationship fields
-            simplified[relName] = transformSingleJsonApiToSimplified(
+            const itemSimplified = transformSingleJsonApiToSimplified(
               { data: nestedData, included: null },
               { context: { 
                 schemaStructure: scopes?.[nestedData.type]?.vars?.schemaInfo?.schema || {},
@@ -696,6 +838,11 @@ export const transformSingleJsonApiToSimplified = (scope, deps) => {
                 scopes
               } }
             );
+            // For polymorphic relationships, add _type field to identify the resource type
+            if (rel?.belongsToPolymorphic) {
+              itemSimplified._type = nestedData.type;
+            }
+            simplified[relName] = itemSimplified;
           }
         }
       }

package/plugins/core/lib/storage/storage-adapter.js

@@ -0,0 +1,160 @@
+const passthrough = (value) => value;
+const identityTranslate = (_field, value) => value;
+const identityScope = (query) => query;
+
+const selectColumnsOnBuilder = (builder, columns) => {
+  if (!columns) return builder;
+  if (Array.isArray(columns)) {
+    columns.forEach((column) => builder.select(column));
+  } else if (typeof columns === 'object') {
+    builder.select(columns);
+  }
+  return builder;
+};
+
+const normalizeArray = (value, normalizeFn) => value.map((entry) => normalizeFn(entry));
+
+const normalizeBelongsToValue = (value) => {
+  if (value === null || value === undefined) return value;
+  if (Array.isArray(value)) {
+    return normalizeArray(value, normalizeBelongsToValue);
+  }
+  return String(value);
+};
+
+const baseAdapter = ({
+  knex,
+  tableName,
+  idColumn,
+  translateColumn,
+  translateFilterValue = identityTranslate,
+  applyResourceScope = identityScope,
+  isCanonical = false,
+}) => {
+  const buildBaseQuery = ({ transaction } = {}) => {
+    const query = (transaction || knex)(tableName);
+    return applyResourceScope(query);
+  };
+
+  return {
+    isCanonical: () => isCanonical,
+    getTableName: () => tableName,
+    getIdColumn: () => idColumn,
+    translateColumn,
+    translateFilterValue,
+    applyResourceScope,
+    buildBaseQuery,
+    selectColumns: (builder, columns) => selectColumnsOnBuilder(builder, columns),
+  };
+};
+
+const createLegacyAdapter = ({ knex, schemaInfo }) => {
+  const tableName = schemaInfo.tableName;
+  const idColumn = schemaInfo.idProperty || 'id';
+
+  const translateColumn = (column) => column;
+
+  return baseAdapter({
+    knex,
+    tableName,
+    idColumn,
+    translateColumn,
+    translateFilterValue: identityTranslate,
+    applyResourceScope: identityScope,
+    isCanonical: false,
+  });
+};
+
+const createCanonicalAdapter = ({ knex, schemaInfo }) => {
+  const descriptor = schemaInfo.descriptor || {};
+  const canonical = descriptor.canonical || {};
+  const canonicalFieldMap = descriptor.canonicalFieldMap || {};
+  const fieldsInfo = descriptor.fields || {};
+  const belongsToInfo = descriptor.belongsTo || {};
+
+  const translateColumn = (field) => {
+    if (!field) return field;
+    if (field === 'id') return 'id';
+
+    const canonicalEntry = canonicalFieldMap[field];
+    if (typeof canonicalEntry === 'string') {
+      return canonicalEntry;
+    }
+    if (canonicalEntry && typeof canonicalEntry === 'object') {
+      if (canonicalEntry.slot) return canonicalEntry.slot;
+      if (canonicalEntry.slotColumn) return canonicalEntry.slotColumn;
+      if (canonicalEntry.idSlot) return canonicalEntry.idSlot;
+      if (canonicalEntry.typeSlot && field.endsWith('_type')) return canonicalEntry.typeSlot;
+    }
+
+    if (!canonicalEntry && field.endsWith('_id')) {
+      const alias = field.slice(0, -3);
+      const aliasEntry = canonicalFieldMap[alias];
+      if (typeof aliasEntry === 'string') return aliasEntry;
+      if (aliasEntry?.idSlot) return aliasEntry.idSlot;
+    }
+
+    if (!canonicalEntry && field.endsWith('_type')) {
+      const alias = field.slice(0, -5);
+      const aliasEntry = canonicalFieldMap[alias];
+      if (aliasEntry?.typeSlot) return aliasEntry.typeSlot;
+    }
+
+    const fieldInfo = fieldsInfo[field];
+    if (fieldInfo?.slot) return fieldInfo.slot;
+
+    const belongsInfo = belongsToInfo[field];
+    if (belongsInfo?.idColumn) return belongsInfo.idColumn;
+
+    return field;
+  };
+
+  const translateFilterValue = (field, value) => {
+    if (value === null || value === undefined) return value;
+
+    const searchField = schemaInfo.searchSchemaStructure?.[field];
+    const schemaField = schemaInfo.schemaStructure?.[field];
+    const isRelationship = Boolean(
+      searchField?.isRelationship
+      || schemaField?.belongsTo
+      || schemaField?.belongsToPolymorphic
+    );
+
+    if (!isRelationship) {
+      if (Array.isArray(value)) {
+        return normalizeArray(value, passthrough);
+      }
+      return value;
+    }
+
+    return normalizeBelongsToValue(value);
+  };
+
+  const applyResourceScope = (query) => {
+    return query
+      .where(canonical.tenantColumn, descriptor.tenant)
+      .where(canonical.resourceColumn, descriptor.resource);
+  };
+
+  return baseAdapter({
+    knex,
+    tableName: canonical.tableName,
+    idColumn: 'id',
+    translateColumn,
+    translateFilterValue,
+    applyResourceScope,
+    isCanonical: true,
+  });
+};
+
+export const createStorageAdapter = ({ knex, schemaInfo }) => {
+  if (!schemaInfo) {
+    throw new Error('createStorageAdapter requires schemaInfo');
+  }
+
+  if (schemaInfo?.descriptor?.canonical?.tableName) {
+    return createCanonicalAdapter({ knex, schemaInfo });
+  }
+
+  return createLegacyAdapter({ knex, schemaInfo });
+};

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

@@ -90,7 +90,7 @@ import { RestApiValidationError } from '../../../../lib/rest-api-errors.js';
  * 
  * // Schema relationships has:
  * // tags: {
- * //   hasMany: 'tags',
+ * //   type: 'manyToMany',
  * //   through: 'article_tags',
  * //   foreignKey: 'article_id',
  * //   otherKey: 'tag_id'
@@ -226,16 +226,8 @@ export const processRelationships = (scope, deps) => {
       }
     }
     
-    // Check for many-to-many relationships defined in relationships object
-    if (relDef?.manyToMany && relData.data !== undefined) {
-      manyToManyRelationships.push({
-        relName,
-        relDef: relDef.manyToMany,  // Pass the manyToMany object, not the whole relationship
-        relData: relData.data || []  // null means empty array for many-to-many
-      });
-    }
-    // Also check for hasMany with through (alternative many-to-many syntax)
-    else if (relDef?.hasMany && relDef?.through && relData.data !== undefined) {
+    // Check relationship type and process accordingly
+    if (relDef?.type === 'manyToMany' && relData.data !== undefined) {
       manyToManyRelationships.push({
         relName,
         relDef: {
@@ -246,6 +238,7 @@ export const processRelationships = (scope, deps) => {
         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 };