DX | 29-09-2025 | Release

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/datasync-filesystem-sdk",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "JavaScript filesystem SDK to query data synced via @contentstack/datasync-content-store-filesystem",
   "main": "dist/index.js",
   "scripts": {

src/stack.ts

@@ -1232,32 +1232,58 @@ export class Stack {
    * @returns {this} - Returns stack instance
    */
   private processOverlappingPaths(pathAnalysis: any): Stack {
-    // Start with independent paths (if any)
+    // Collect ALL paths first
+    const allPaths: string[] = []
+
+    // Add independent paths
     if (pathAnalysis.independentPaths.length > 0) {
-      this.q.includeSpecificReferences = pathAnalysis.independentPaths
+      allPaths.push(...pathAnalysis.independentPaths)
     }
 
-    // Process each overlapping group by using the most specific path
+    // Add all paths from overlapping groups
     pathAnalysis.overlappingGroups.forEach((group: string[]) => {
-      // Sort group by length (longest/most specific first)
-      const sortedGroup = group.sort((a, b) => b.length - a.length)
-
-      // Use the most specific path from each group
-      const mostSpecificPath = sortedGroup[0]
-
-      // If this is the first group and we have no independent paths,
-      // set the includeSpecificReferences
-      if (!this.q.includeSpecificReferences) {
-        this.q.includeSpecificReferences = [mostSpecificPath]
-      } else {
-        // Add the most specific path to existing references
-        this.q.includeSpecificReferences.push(mostSpecificPath)
-      }
+      allPaths.push(...group)
     })
 
+    // Remove exact duplicates
+    const uniquePaths = [...new Set(allPaths)]
+
+    // Smart filtering: remove parent paths that are fully covered by child paths
+    const filteredPaths = this.removeRedundantPaths(uniquePaths)
+
+    this.q.includeSpecificReferences = filteredPaths
     return this
   }
 
+  /**
+   * @private
+   * @method removeRedundantPaths
+   * @description Removes parent paths that are fully covered by more specific child paths
+   * Example: ["content", "content.content"] → ["content.content"]
+   * But keeps: ["form", "form.fields", "form.fields.rules"] → all three (not redundant)
+   */
+  private removeRedundantPaths(paths: string[]): string[] {
+    // Sort by length (longest first) to prioritize more specific paths
+    const sortedPaths = paths.sort((a, b) => b.length - a.length)
+    const result: string[] = []
+
+    for (const currentPath of sortedPaths) {
+      // Check if this path is made redundant by a more specific path already in result
+      const isRedundant = result.some(existingPath => {
+        // Check if currentPath is a direct parent of existingPath
+        return existingPath.startsWith(currentPath + '.') && 
+               existingPath.split('.').length === currentPath.split('.').length + 1
+      })
+
+      if (!isRedundant) {
+        result.push(currentPath)
+      }
+    }
+
+    return result
+  }
+
+
   /**
    * @private
    * @method preProcess

typings/stack.d.ts

@@ -518,6 +518,14 @@ export declare class Stack {
      * @returns {this} - Returns stack instance
      */
     private processOverlappingPaths;
+    /**
+     * @private
+     * @method removeRedundantPaths
+     * @description Removes parent paths that are fully covered by more specific child paths
+     * Example: ["content", "content.content"] → ["content.content"]
+     * But keeps: ["form", "form.fields", "form.fields.rules"] → all three (not redundant)
+     */
+    private removeRedundantPaths;
     /**
      * @private
      * @method preProcess