Filter: combine inverseTags and inverseFlag (#199)

* test: Added test with inverseTags with inverseFlags

* Filter: combine inverseTags and inverseFlag

Author: thim81

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## [1.29.5] - 2026-02-28
 
+- Filter: combine inverseTags and inverseFlag (#192)
 - Filter: preserve inverse flag filtering with stripFlags (#193)
 - Types: Update Typescript typings (#194)
 

openapi-format.js

@@ -381,6 +381,7 @@ async function openapiFilter(oaObj, options) {
       // Filter out object matching the inverse "tags"
       if (
         inverseFilterArray.length > 0 &&
+        inverseFilterFlags.length === 0 &&
         this.key === 'tags' &&
         !inverseFilterArray.some(i => node.includes(i)) &&
         this.parent.parent !== undefined
@@ -390,7 +391,12 @@ async function openapiFilter(oaObj, options) {
       }
 
       // Filter out the top level tags matching the inverse "tags"
-      if (inverseFilterArray.length > 0 && this.key === 'tags' && this.parent.parent === undefined) {
+      if (
+        inverseFilterArray.length > 0 &&
+        inverseFilterFlags.length === 0 &&
+        this.key === 'tags' &&
+        this.parent.parent === undefined
+      ) {
         // debugFilterStep = 'Filter - inverse top tags'
         node = node.filter(value => inverseFilterArray.includes(value.name));
         this.update(node);
@@ -437,6 +443,7 @@ async function openapiFilter(oaObj, options) {
       // Keep fields matching the inverseFlags array
       if (
         inverseFilterFlags.length > 0 &&
+        inverseFilterArray.length === 0 &&
         (this.path[0] === 'tags' || this.path[0] === 'x-tagGroups') &&
         this.level === 1
       ) {
@@ -551,23 +558,36 @@ async function openapiFilter(oaObj, options) {
       }
     }
 
-    // Filter out operations not matching inverseFilterArray
-    if (inverseFilterArray.length > 0 && this.parent && this.parent.parent && this.parent.parent.key === 'paths') {
-      if (node.tags === undefined || !inverseFilterArray.some(i => node.tags.includes(i))) {
-        this.delete();
-      }
-    }
-
-    // Keep fields matching the inverseFlags
-    if (inverseFilterFlags.length > 0 && this.path[0] === 'paths' && this.level === 3) {
-      const itmObj = node;
-      const matchesInverseFlag = inverseFilterFlags.some(flagKey => {
-        return itmObj.hasOwnProperty(flagKey);
-      });
-
-      if (!matchesInverseFlag) {
-        // debugFilterStep = 'Filter - Single field - inverseFlags'
-        this.remove();
+    // Filter operations for inverseTags / inverseFlags.
+    // When both are configured, treat them as a union (keep if either matches).
+    if (
+      this.path[0] === 'paths' &&
+      this.level === 3 &&
+      this.parent &&
+      this.parent.parent &&
+      this.parent.parent.key === 'paths'
+    ) {
+      const hasInverseTags = inverseFilterArray.length > 0;
+      const hasInverseFlags = inverseFilterFlags.length > 0;
+      if (hasInverseTags || hasInverseFlags) {
+        const operation = node || {};
+        const matchesInverseTag =
+          hasInverseTags && Array.isArray(operation.tags)
+            ? inverseFilterArray.some(i => operation.tags.includes(i))
+            : false;
+        const matchesInverseFlag = hasInverseFlags
+          ? inverseFilterFlags.some(flagKey => operation.hasOwnProperty(flagKey))
+          : false;
+        const shouldKeep =
+          hasInverseTags && hasInverseFlags
+            ? matchesInverseTag || matchesInverseFlag
+            : hasInverseTags
+              ? matchesInverseTag
+              : matchesInverseFlag;
+
+        if (!shouldKeep) {
+          this.delete();
+        }
       }
     }
 
@@ -636,6 +656,25 @@ async function openapiFilter(oaObj, options) {
     }
   });
 
+  // Keep top-level tags that are still referenced by remaining operations.
+  // Apply this only when inverseTags and inverseFlags are both configured.
+  // (inverseFlags-only mode should preserve the existing flagged-tag behavior.)
+  if (Array.isArray(jsonObj.tags) && inverseFilterArray.length > 0 && inverseFilterFlags.length > 0) {
+    const usedTags = new Set();
+    if (jsonObj.paths && typeof jsonObj.paths === 'object') {
+      Object.values(jsonObj.paths).forEach(pathItem => {
+        if (pathItem && typeof pathItem === 'object') {
+          Object.values(pathItem).forEach(operation => {
+            if (operation && typeof operation === 'object' && Array.isArray(operation.tags)) {
+              operation.tags.forEach(tag => usedTags.add(tag));
+            }
+          });
+        }
+      });
+    }
+    jsonObj.tags = jsonObj.tags.filter(tagObj => tagObj && usedTags.has(tagObj.name));
+  }
+
   // Calculate comps.meta.total at the end
   // comps.meta.total = Object.keys(comps.schemas).length +
   //   Object.keys(comps.responses).length +

test/filtering.test.js

@@ -320,6 +320,16 @@ describe('openapi-format CLI filtering tests', () => {
     });
   });
 
+  describe('yaml-filter-inverse-flags-inverse-tags', () => {
+    it('yaml-filter-inverse-flags-inverse-tags - should match expected output', async () => {
+      const testName = 'yaml-filter-inverse-flags-inverse-tags';
+      const {result, outputBefore, outputAfter} = await testUtils.loadTest(testName);
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('formatted successfully');
+      expect(outputAfter).toStrictEqual(outputBefore);
+    });
+  });
+
   describe('isUsedComp', () => {
     it('returns false for non-object input', () => {
       expect(isUsedComp(null, 'schemas')).toBe(false);

test/yaml-filter-inverse-flags-inverse-tags/customFilter.yaml

@@ -0,0 +1,11 @@
+inverseTags:
+  - foo
+inverseFlags:
+  - x-public
+unusedComponents:
+  - schemas
+  - parameters
+  - examples
+  - headers
+  - requestBodies
+  - responses

test/yaml-filter-inverse-flags-inverse-tags/input.yaml

@@ -0,0 +1,39 @@
+openapi: 3.0.0
+info:
+  title: API
+  version: 1.0.0
+tags:
+  - name: foo
+  - name: bar
+paths:
+  /foo-op:
+    get:
+      operationId: fooOp
+      tags:
+        - foo
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Foo'
+  /public-op:
+    get:
+      operationId: publicOp
+      tags:
+        - bar
+      x-public: true
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Bar'
+components:
+  schemas:
+    Foo:
+      type: object
+    Bar:
+      type: object

test/yaml-filter-inverse-flags-inverse-tags/options.yaml

@@ -0,0 +1,4 @@
+verbose: true
+no-sort: true
+output: output.yaml
+filterFile: customFilter.yaml

test/yaml-filter-inverse-flags-inverse-tags/output.yaml

@@ -0,0 +1,39 @@
+openapi: 3.0.0
+info:
+  title: API
+  version: 1.0.0
+tags:
+  - name: foo
+  - name: bar
+paths:
+  /foo-op:
+    get:
+      operationId: fooOp
+      tags:
+        - foo
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Foo'
+  /public-op:
+    get:
+      operationId: publicOp
+      tags:
+        - bar
+      x-public: true
+      responses:
+        '200':
+          description: ok
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Bar'
+components:
+  schemas:
+    Foo:
+      type: object
+    Bar:
+      type: object