json-rest-api 1.0.10 → 1.0.13

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

@@ -167,16 +167,18 @@ export function ensureSearchFieldsAreIndexed(searchSchema) {
  * // }
  * 
  * @example
- * // Input: Conflict detection
+ * // Input: Explicit searchSchema takes precedence
  * const schema = {
  *   email: { type: 'string', search: true }
  * };
  * const explicitSearchSchema = {
  *   email: { type: 'string', filterOperator: 'contains' }
  * };
- * generateSearchSchemaFromSchema(schema, explicitSearchSchema);
- * // Throws: RestApiValidationError
- * // "Field 'email' is defined in both schema (with search: true) and explicit searchSchema."
+ * const result = generateSearchSchemaFromSchema(schema, explicitSearchSchema);
+ * // Output: Explicit searchSchema wins
+ * // {
+ * //   email: { type: 'string', filterOperator: 'contains' }  // Uses explicit definition
+ * // }
  * 
  * @example
  * // Input: Virtual search fields
@@ -215,15 +217,16 @@ export function ensureSearchFieldsAreIndexed(searchSchema) {
  * - Provides flexible search configuration options
  * - Enables virtual fields for cross-table searches
  * - Supports range queries (before/after patterns)
- * - Validates no duplicate definitions exist
+ * - Merges search:true fields with explicit searchSchema
+ * - Explicit searchSchema always takes precedence
  * - Allows storage plugins to optimize queries
  * 
  * Data flow:
  * 1. Starts with explicit searchSchema (if any)
  * 2. Processes schema fields with 'search' property
- * 3. Handles multiple filters from single field
- * 4. Processes virtual search definitions
- * 5. Detects and throws on conflicts
+ * 3. Skips fields already in explicit searchSchema (no conflicts)
+ * 4. Handles multiple filters from single field
+ * 5. Processes virtual search definitions
  * 6. Returns merged searchSchema or null
  */
 export const generateSearchSchemaFromSchema = (schema, explicitSearchSchema) => {
@@ -240,28 +243,32 @@ export const generateSearchSchemaFromSchema = (schema, explicitSearchSchema) =>
     
     if (effectiveSearch) {
       if (effectiveSearch === true) {
-        // Check for conflicts with explicit searchSchema
-        if (searchSchema[fieldName]) {
-          throw new RestApiValidationError(
-            `Field '${fieldName}' is defined in both schema (with search: true) and explicit searchSchema. Remove one definition to avoid conflicts.`,
-            { 
-              fields: [fieldName],
-              violations: [{
-                field: fieldName,
-                rule: 'duplicate_search_field',
-                message: 'Field cannot be defined in both schema and searchSchema'
-              }]
-            }
-          );
+        // For belongsTo relationships, use the relationship name (as property) instead of the field name
+        const searchFieldName = (fieldDef.belongsTo && fieldDef.as) ? fieldDef.as : fieldName;
+        
+        // Check if field already exists in explicit searchSchema
+        if (searchSchema[searchFieldName]) {
+          // Skip - explicit searchSchema takes precedence
+          // This allows searchSchema to override fields marked with search:true
+          return;
         }
         
         // Simple boolean - copy entire field definition (except search) and add filterOperator
         const { search, ...fieldDefWithoutSearch } = fieldDef;
-        searchSchema[fieldName] = {
+        const searchEntry = {
           ...fieldDefWithoutSearch,
           // Preserve existing filterOperator or default to '='
           filterOperator: fieldDefWithoutSearch.filterOperator || '='
         };
+        
+        // For belongsTo relationships, add metadata to map back to the actual field
+        if (fieldDef.belongsTo && fieldDef.as) {
+          searchEntry.actualField = fieldName;  // Maps to the DB column
+          searchEntry.isRelationship = true;
+          searchEntry.targetResource = fieldDef.belongsTo;
+        }
+        
+        searchSchema[searchFieldName] = searchEntry;
       } else if (typeof effectiveSearch === 'object') {
         // Check if search defines multiple filter fields
         const hasNestedFilters = Object.values(effectiveSearch).some(
@@ -271,19 +278,10 @@ export const generateSearchSchemaFromSchema = (schema, explicitSearchSchema) =>
         if (hasNestedFilters) {
           // Multiple filters from one field (like published_after/before)
           Object.entries(effectiveSearch).forEach(([filterName, filterDef]) => {
-            // Check for conflicts
+            // Check if filter already exists in explicit searchSchema
             if (searchSchema[filterName]) {
-              throw new RestApiValidationError(
-                `Field '${filterName}' is defined in both schema (with search) and explicit searchSchema. Remove one definition to avoid conflicts.`,
-                { 
-                  fields: [filterName],
-                  violations: [{
-                    field: filterName,
-                    rule: 'duplicate_search_field',
-                    message: 'Field cannot be defined in both schema and searchSchema'
-                  }]
-                }
-              );
+              // Skip - explicit searchSchema takes precedence
+              return;
             }
             
             searchSchema[filterName] = {
@@ -293,26 +291,29 @@ export const generateSearchSchemaFromSchema = (schema, explicitSearchSchema) =>
             };
           });
         } else {
-          // Check for conflicts
-          if (searchSchema[fieldName]) {
-            throw new RestApiValidationError(
-              `Field '${fieldName}' is defined in both schema (with search) and explicit searchSchema. Remove one definition to avoid conflicts.`,
-              { 
-                fields: [fieldName],
-                violations: [{
-                  field: fieldName,
-                  rule: 'duplicate_search_field',
-                  message: 'Field cannot be defined in both schema and searchSchema'
-                }]
-              }
-            );
+          // For belongsTo relationships, use the relationship name (as property) instead of the field name
+          const searchFieldName = (fieldDef.belongsTo && fieldDef.as) ? fieldDef.as : fieldName;
+          
+          // Check if field already exists in explicit searchSchema
+          if (searchSchema[searchFieldName]) {
+            // Skip - explicit searchSchema takes precedence
+            return;
           }
           
           // Single filter with config
-          searchSchema[fieldName] = {
+          const searchEntry = {
             type: fieldDef.type,
             ...effectiveSearch
           };
+          
+          // For belongsTo relationships, add metadata to map back to the actual field
+          if (fieldDef.belongsTo && fieldDef.as) {
+            searchEntry.actualField = fieldName;  // Maps to the DB column
+            searchEntry.isRelationship = true;
+            searchEntry.targetResource = fieldDef.belongsTo;
+          }
+          
+          searchSchema[searchFieldName] = searchEntry;
         }
       }
     }
@@ -321,19 +322,10 @@ export const generateSearchSchemaFromSchema = (schema, explicitSearchSchema) =>
   // Handle _virtual search definitions
   if (schema._virtual?.search) {
     Object.entries(schema._virtual.search).forEach(([filterName, filterDef]) => {
-      // Check for conflicts
+      // Check if filter already exists in explicit searchSchema
       if (searchSchema[filterName]) {
-        throw new RestApiValidationError(
-          `Field '${filterName}' is defined in both schema (_virtual.search) and explicit searchSchema. Remove one definition to avoid conflicts.`,
-          { 
-            fields: [filterName],
-            violations: [{
-              field: filterName,
-              rule: 'duplicate_search_field',
-              message: 'Field cannot be defined in both schema and searchSchema'
-            }]
-          }
-        );
+        // Skip - explicit searchSchema takes precedence
+        return;
       }
       
       searchSchema[filterName] = filterDef;

package/plugins/core/lib/querying-writing/scope-validations.js

@@ -74,7 +74,8 @@
  *     scopeOptions: {
  *       relationships: {
  *         posts: {
- *           hasMany: 'posts'
+ *           type: 'hasMany',
+ *           target: 'posts'
  *           // Missing: foreignKey
  *         }
  *       }
@@ -154,8 +155,8 @@ export function validateRelationships({ context, scopes }) {
       }
     }
     
-    // Validate hasMany relationships require foreignKey
-    if (relDef.hasMany) {
+    // Validate based on relationship type
+    if (relDef.type === 'hasMany') {
       const validation = validateHasManyRelationship(relDef, relName, scopeName);
       if (!validation.valid) {
         throw new Error(
@@ -164,8 +165,16 @@ export function validateRelationships({ context, scopes }) {
       }
     }
     
-    // Validate manyToMany relationships require both foreignKey and otherKey
-    if (relDef.manyToMany) {
+    if (relDef.type === 'hasOne') {
+      const validation = validateHasOneRelationship(relDef, relName, scopeName);
+      if (!validation.valid) {
+        throw new Error(
+          `Invalid hasOne relationship '${relName}' in scope '${scopeName}': ${validation.error}`
+        );
+      }
+    }
+    
+    if (relDef.type === 'manyToMany') {
       const validation = validateManyToManyRelationship(relDef, relName, scopeName);
       if (!validation.valid) {
         throw new Error(
@@ -290,7 +299,8 @@ const validatePolymorphicRelationship = (relDef, scopeName, scopes) => {
  * @example
  * // Input: Valid hasMany configuration
  * const relDef = {
- *   hasMany: 'posts',
+ *   type: 'hasMany',
+ *   target: 'posts',
  *   foreignKey: 'author_id'              // Required!
  * };
  * validateHasManyRelationship(relDef, 'posts', 'users');
@@ -299,7 +309,8 @@ const validatePolymorphicRelationship = (relDef, scopeName, scopes) => {
  * @example
  * // Input: Missing required foreignKey
  * const relDef = {
- *   hasMany: 'posts'
+ *   type: 'hasMany',
+ *   target: 'posts'
  *   // Missing: foreignKey
  * };
  * validateHasManyRelationship(relDef, 'posts', 'users');
@@ -311,7 +322,8 @@ const validatePolymorphicRelationship = (relDef, scopeName, scopes) => {
  * @example
  * // Input: Polymorphic hasMany with 'via' (doesn't need foreignKey)
  * const relDef = {
- *   hasMany: 'comments',
+ *   type: 'hasMany',
+ *   target: 'comments',
  *   via: 'commentable'                   // Uses polymorphic relationship
  * };
  * validateHasManyRelationship(relDef, 'comments', 'posts');
@@ -320,6 +332,14 @@ const validatePolymorphicRelationship = (relDef, scopeName, scopes) => {
  * @private
  */
 const validateHasManyRelationship = (relDef, relName, scopeName) => {
+  // Validate target is specified
+  if (!relDef.target) {
+    return { 
+      valid: false, 
+      error: `hasMany relationship requires 'target' to be specified.`
+    };
+  }
+  
   // Polymorphic hasMany relationships using 'via' don't need foreignKey
   // They use the polymorphic fields (typeField, idField) from the belongsToPolymorphic relationship
   if (relDef.via) {
@@ -340,11 +360,49 @@ const validateHasManyRelationship = (relDef, relName, scopeName) => {
     };
   }
   
-  // If through is specified, also require otherKey for many-to-many
-  if (relDef.through && !relDef.otherKey) {
+  return { valid: true };
+};
+
+/**
+ * Validates a hasOne relationship definition
+ * 
+ * @param {Object} relDef - Relationship definition with hasOne
+ * @param {string} relName - Relationship name
+ * @param {string} scopeName - Scope being registered
+ * @returns {Object} Validation result {valid: boolean, error?: string}
+ * 
+ * @example
+ * // Input: Valid hasOne configuration
+ * const relDef = {
+ *   type: 'hasOne',
+ *   target: 'profile',
+ *   foreignKey: 'user_id'              // Required!
+ * };
+ * validateHasOneRelationship(relDef, 'profile', 'users');
+ * // Output: { valid: true }
+ * 
+ * @private
+ */
+const validateHasOneRelationship = (relDef, relName, scopeName) => {
+  // Validate target is specified
+  if (!relDef.target) {
+    return { 
+      valid: false, 
+      error: `hasOne relationship requires 'target' to be specified.`
+    };
+  }
+  
+  if (!relDef.foreignKey) {
+    return { 
+      valid: false, 
+      error: `hasOne relationship requires foreignKey to be specified. Add foreignKey: '<field_name>' to the relationship definition.`
+    };
+  }
+  
+  if (typeof relDef.foreignKey !== 'string') {
     return { 
       valid: false, 
-      error: `hasMany relationship with 'through' requires both foreignKey and otherKey to be specified`
+      error: `hasOne relationship foreignKey must be a string, got ${typeof relDef.foreignKey}`
     };
   }
   
@@ -362,11 +420,10 @@ const validateHasManyRelationship = (relDef, relName, scopeName) => {
  * @example
  * // Input: Valid manyToMany configuration
  * const relDef = {
- *   manyToMany: {
- *     through: 'article_tags',           // Pivot table
- *     foreignKey: 'article_id',          // This scope's FK
- *     otherKey: 'tag_id'                 // Other scope's FK
- *   }
+ *   type: 'manyToMany',
+ *   through: 'article_tags',           // Pivot table
+ *   foreignKey: 'article_id',          // This scope's FK
+ *   otherKey: 'tag_id'                 // Other scope's FK
  * };
  * validateManyToManyRelationship(relDef, 'tags', 'articles');
  * // Output: { valid: true }
@@ -374,11 +431,10 @@ const validateHasManyRelationship = (relDef, relName, scopeName) => {
  * @example
  * // Input: Missing required fields
  * const relDef = {
- *   manyToMany: {
- *     through: 'article_tags',
- *     foreignKey: 'article_id'
- *     // Missing: otherKey
- *   }
+ *   type: 'manyToMany',
+ *   through: 'article_tags',
+ *   foreignKey: 'article_id'
+ *   // Missing: otherKey
  * };
  * validateManyToManyRelationship(relDef, 'tags', 'articles');
  * // Output: { 
@@ -389,7 +445,7 @@ const validateHasManyRelationship = (relDef, relName, scopeName) => {
  * @private
  */
 const validateManyToManyRelationship = (relDef, relName, scopeName) => {
-  const { through, foreignKey, otherKey } = relDef.manyToMany;
+  const { through, foreignKey, otherKey } = relDef;
   
   if (!through) {
     return {