orval-labs
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎packages/angular/src/http-resource.ts‎
Lines changed: 5 additions & 4 deletions b/‎packages/angular/src/http-resource.ts‎
Lines changed: 5 additions & 4 deletions
diff --git a/‎packages/angular/src/utils.test.ts‎
Lines changed: 25 additions & 1 deletion b/‎packages/angular/src/utils.test.ts‎
Lines changed: 25 additions & 1 deletion
diff --git a/‎packages/angular/src/utils.ts‎
Lines changed: 11 additions & 17 deletions b/‎packages/angular/src/utils.ts‎
Lines changed: 11 additions & 17 deletions
diff --git a/‎packages/core/src/utils/index.ts‎
Lines changed: 1 addition & 0 deletions b/‎packages/core/src/utils/index.ts‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎packages/core/src/utils/tags.test.ts‎
Lines changed: 93 additions & 0 deletions b/‎packages/core/src/utils/tags.test.ts‎
Lines changed: 93 additions & 0 deletions
diff --git a/‎packages/core/src/utils/tags.ts‎
Lines changed: 55 additions & 0 deletions b/‎packages/core/src/utils/tags.ts‎
Lines changed: 55 additions & 0 deletions
diff --git a/‎packages/core/src/writers/tags-mode.test.ts‎
Lines changed: 63 additions & 0 deletions b/‎packages/core/src/writers/tags-mode.test.ts‎
Lines changed: 63 additions & 0 deletions
@@ -1,6 +1,7 @@
 mock-backend
 dist
 .rpt2_cache
+.impeccable
 
 ### macOS ###
 *.DS_Store
 
@@ -18,10 +18,11 @@ import {
   getFileInfo,
   getFullRoute,
   GetterPropType,
+  getOperationTagKey,
+  getTagKey,
   isObject,
   isSyntheticDefaultImportsAllow,
   jsDoc,
-  kebab,
   makeRouteSafe,
   type NormalizedOutputOptions,
   type OpenApiInfoObject,
@@ -172,7 +173,7 @@ const getVerbOptionsRecord = (
   );
 
 const getPrimaryTag = (verbOption: GeneratorVerbOptions): string =>
-  kebab(verbOption.tags[0] ?? 'default');
+  getOperationTagKey(verbOption);
 
 const hasRetrievalOperations = (
   verbOptions: Record<string, GeneratorVerbOptions>,
@@ -1495,11 +1496,11 @@ const getHttpResourceExtraFilePath = (
 
   switch (output.mode) {
     case OutputMode.TAGS: {
-      const normalizedTag = kebab(tag ?? 'default');
+      const normalizedTag = getTagKey(tag);
       return upath.joinSafe(dirname, `${normalizedTag}.resource${extension}`);
     }
     case OutputMode.TAGS_SPLIT: {
-      const normalizedTag = kebab(tag ?? 'default');
+      const normalizedTag = getTagKey(tag);
       return upath.joinSafe(
         dirname,
         normalizedTag,
 
@@ -482,14 +482,28 @@ describe('getRelevantVerbOptionsForTag', () => {
     expect(result[0].operationId).toBe('op1');
   });
 
-  it('matches tags case-insensitively via camelCase normalisation', () => {
+  it('matches tags case-insensitively via kebab normalisation', () => {
     const verbOptions = {
       op1: makeVerb('op1', ['Pet-Store']),
     };
     const result = getRelevantVerbOptionsForTag(verbOptions, 'pet-store');
     expect(result).toHaveLength(1);
   });
 
+  it('matches multi-word tags with acronym prefixes (e.g. "AB Widget" → "ab-widget")', () => {
+    const verbOptions = {
+      op1: makeVerb('op1', ['AB Widget']),
+      op2: makeVerb('op2', ['Widget']),
+    };
+    const abResult = getRelevantVerbOptionsForTag(verbOptions, 'ab-widget');
+    expect(abResult).toHaveLength(1);
+    expect(abResult[0].operationId).toBe('op1');
+
+    const widgetResult = getRelevantVerbOptionsForTag(verbOptions, 'widget');
+    expect(widgetResult).toHaveLength(1);
+    expect(widgetResult[0].operationId).toBe('op2');
+  });
+
   it('returns empty array when no verbs match the tag', () => {
     const verbOptions = {
       op1: makeVerb('op1', ['pets']),
@@ -500,4 +514,14 @@ describe('getRelevantVerbOptionsForTag', () => {
   it('returns empty array for empty verbOptions', () => {
     expect(getRelevantVerbOptionsForTag({}, 'pets')).toHaveLength(0);
   });
+
+  it('treats an empty-string tag as the default bucket, not as "no filter"', () => {
+    const verbOptions = {
+      untagged: makeVerb('untagged', []),
+      tagged: makeVerb('tagged', ['pets']),
+    };
+    const result = getRelevantVerbOptionsForTag(verbOptions, '');
+    expect(result).toHaveLength(1);
+    expect(result[0].operationId).toBe('untagged');
+  });
 });
@@ -1,11 +1,10 @@
 import {
-  camel,
-  DefaultTag,
   type GeneratorVerbOptions,
   getAngularFilteredParamsHelperBody,
   getDefaultContentType,
   isBoolean,
   isObject,
+  isOperationInTagBucket,
   type NormalizedOutputOptions,
   pascal,
   type ResReqTypesValue,
@@ -143,28 +142,23 @@ export const createRouteRegistry = () => {
 /**
  * Returns only the operations that belong to the current tag output.
  *
- * In `tags` / `tags-split` mode the writer may route untagged operations into
- * the implicit `default` bucket. When a generated tag file targets that bucket
- * we also include operations whose original tag list was empty; a literal
- * user-defined `default` tag is treated like any other tag unless untagged
- * operations are present in the same output.
+ * Tag matching is delegated to {@link isOperationInTagBucket}, the single source
+ * of truth for tag-bucket identity. Untagged operations resolve to the implicit
+ * `default` bucket, matching how the core writer routes them in
+ * `tags` / `tags-split` mode.
  */
 export const getRelevantVerbOptionsForTag = (
   verbOptions: Record<string, GeneratorVerbOptions>,
   tag?: string,
 ): GeneratorVerbOptions[] => {
   const allVerbOptions = Object.values(verbOptions);
-  if (!tag) return allVerbOptions;
+  // Only an absent tag means "no filter"; an empty/whitespace tag is a real
+  // bucket key that `isOperationInTagBucket` normalises to `default`, matching
+  // the core writer instead of silently matching every operation.
+  if (tag == null) return allVerbOptions;
 
-  const camelTag = camel(tag);
-  const includeUntaggedOperations =
-    tag === DefaultTag &&
-    allVerbOptions.some((verbOption) => verbOption.tags.length === 0);
-
-  return allVerbOptions.filter(
-    (verbOption) =>
-      verbOption.tags.some((currentTag) => camel(currentTag) === camelTag) ||
-      (includeUntaggedOperations && verbOption.tags.length === 0),
+  return allVerbOptions.filter((verbOption) =>
+    isOperationInTagBucket(verbOption, tag),
   );
 };
 
 
@@ -20,4 +20,5 @@ export * from './resolve-version';
 export * from './schemas-options';
 export * from './sort';
 export * from './string';
+export * from './tags';
 export * from './tsconfig';
@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+
+import { getOperationTagKey, getTagKey, isOperationInTagBucket } from './tags';
+import { kebab } from './case';
+
+describe('getTagKey', () => {
+  it('kebab-cases a simple tag', () => {
+    expect(getTagKey('pets')).toBe('pets');
+  });
+
+  it('kebab-cases multi-word tags', () => {
+    expect(getTagKey('Pet Store')).toBe('pet-store');
+  });
+
+  it('normalises acronym-prefixed multi-word tags (the bug class)', () => {
+    // `camel("AB Widget")` would give "aBWidget", which does NOT round-trip
+    // through the bucket key. `kebab` does.
+    expect(getTagKey('AB Widget')).toBe('ab-widget');
+  });
+
+  it('is idempotent: applying it to its own output is a no-op', () => {
+    for (const tag of [
+      'pets',
+      'Pet Store',
+      'AB Widget',
+      'user-admin',
+      'HTTPServer',
+      'v1.users',
+    ]) {
+      const once = getTagKey(tag);
+      expect(getTagKey(once)).toBe(once);
+    }
+  });
+
+  it('falls back to the default bucket for missing tags', () => {
+    expect(getTagKey()).toBe('default');
+    expect(getTagKey(undefined)).toBe('default');
+  });
+
+  it('falls back to the default bucket for empty/whitespace tags', () => {
+    expect(getTagKey('')).toBe('default');
+    expect(getTagKey('   ')).toBe('default');
+  });
+
+  it('agrees with a raw kebab() call on the same input', () => {
+    for (const tag of ['pets', 'Pet Store', 'AB Widget', 'user/admin']) {
+      expect(getTagKey(tag)).toBe(kebab(tag));
+    }
+  });
+});
+
+describe('getOperationTagKey', () => {
+  it('derives the key from the first tag', () => {
+    expect(getOperationTagKey({ tags: ['AB Widget', 'Other'] })).toBe(
+      'ab-widget',
+    );
+  });
+
+  it('maps untagged operations to the default bucket', () => {
+    expect(getOperationTagKey({ tags: [] })).toBe('default');
+  });
+});
+
+describe('isOperationInTagBucket', () => {
+  it('matches an operation to its own bucket regardless of spelling', () => {
+    const op = { tags: ['AB Widget'] };
+    expect(isOperationInTagBucket(op, 'ab-widget')).toBe(true);
+    // A caller that passes the raw tag still matches, because both sides are
+    // normalised.
+    expect(isOperationInTagBucket(op, 'AB Widget')).toBe(true);
+  });
+
+  it('does not match an operation in a different bucket', () => {
+    expect(isOperationInTagBucket({ tags: ['Widget'] }, 'ab-widget')).toBe(
+      false,
+    );
+  });
+
+  it('matches every operation when no tag bucket is given', () => {
+    expect(isOperationInTagBucket({ tags: ['anything'] })).toBe(true);
+    expect(isOperationInTagBucket({ tags: [] }, undefined)).toBe(true);
+  });
+
+  it('treats an empty/whitespace tag bucket as the default bucket, not match-all', () => {
+    expect(isOperationInTagBucket({ tags: [] }, '')).toBe(true);
+    expect(isOperationInTagBucket({ tags: ['anything'] }, '')).toBe(false);
+  });
+
+  it('places untagged operations in the default bucket', () => {
+    expect(isOperationInTagBucket({ tags: [] }, 'default')).toBe(true);
+    expect(isOperationInTagBucket({ tags: [] }, 'pets')).toBe(false);
+  });
+});
@@ -0,0 +1,55 @@
+import { DefaultTag } from '../types';
+import { kebab } from './case';
+
+/**
+ * Canonical bucket key for a single OpenAPI tag.
+ *
+ * In `tags` / `tags-split` mode operations are routed into files by their first
+ * tag. This function is the **single source of truth** for turning a tag (or a
+ * missing tag) into the key that identifies that file bucket. Every place that
+ * groups operations by tag, derives a per-tag file/directory name, or checks
+ * whether an operation belongs to a tag MUST go through here so that the
+ * "build the key" side and the "look the key up" side can never disagree.
+ *
+ * The result is `kebab`-cased. `kebab` is idempotent
+ * (`kebab(kebab(x)) === kebab(x)`), so it is always safe to call this on a value
+ * that is already a canonical key. Other case functions (`camel`, `pascal`) are
+ * NOT safe here: they do not round-trip through the bucket key for tags
+ * containing acronyms or spaces (e.g. `"AB Widget"`), which is exactly the class
+ * of bug this module exists to prevent.
+ *
+ * Missing or empty tags map to the implicit {@link DefaultTag} bucket.
+ */
+export function getTagKey(tag?: string): string {
+  const normalizedTag = tag?.trim();
+  return kebab(normalizedTag ? normalizedTag : DefaultTag);
+}
+
+/**
+ * Canonical bucket key for an operation, derived from its primary (first) tag.
+ *
+ * Untagged operations resolve to the {@link DefaultTag} bucket.
+ */
+export function getOperationTagKey(operation: { tags: string[] }): string {
+  return getTagKey(operation.tags[0]);
+}
+
+/**
+ * Whether an operation belongs to the given tag bucket.
+ *
+ * Both sides are normalised through {@link getTagKey}, so the comparison is
+ * correct regardless of how `tagKey` was spelled or cased by the caller. An
+ * absent (`undefined`) `tagKey` matches every operation (the "no tag filter"
+ * case); an empty/whitespace `tagKey` is normalised to the {@link DefaultTag}
+ * bucket like any other tag.
+ *
+ * Prefer this over hand-rolling `operation.tags[0] === tagKey`: a raw tag
+ * compared against a canonical key silently fails for multi-word/acronym tags.
+ */
+export function isOperationInTagBucket(
+  operation: { tags: string[] },
+  tagKey?: string,
+): boolean {
+  if (tagKey == null) return true;
+  return getOperationTagKey(operation) === getTagKey(tagKey);
+}
@@ -410,3 +410,66 @@ describe('writeTagsMode — schemas import extension follows tsconfig module', (
     );
   });
 });
+
+// Regression: footer `operationNames` drives per-operation return-type exports
+// (e.g. Angular `*ClientResult` aliases). Untagged operations are routed into
+// the implicit `default` bucket by `addDefaultTagIfEmpty`, so the default
+// bucket's footer must receive their names too. The old filter excluded them
+// via a `tags.length > 0` guard, so the default-tag file silently dropped its
+// footer exports.
+
+describe('writeTagsMode — default-bucket footer includes untagged operations', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'orval-tags-mode-'));
+  });
+
+  afterEach(() => {
+    fs.removeSync(tmpDir);
+    vi.restoreAllMocks();
+  });
+
+  it('passes untagged operation names to the default-bucket footer', async () => {
+    const target = path.join(tmpDir, 'petstore.ts');
+    const baseProps = createSplitModeProps(target);
+
+    const footerSpy = vi.fn((_args: { operationNames: string[] }) => ({
+      implementation: '',
+      implementationMock: '',
+    }));
+
+    const props = {
+      ...baseProps,
+      builder: {
+        ...baseProps.builder,
+        footer: footerSpy,
+        operations: {
+          listPets: createSplitModeOperation({
+            tags: ['pets'],
+            operationName: 'listPets',
+          }),
+          getHealth: createSplitModeOperation({
+            tags: [],
+            operationName: 'getHealth',
+          }),
+        },
+      } as unknown as typeof baseProps.builder,
+      output: createSplitModeOutput(target, { mode: OutputMode.TAGS }),
+    };
+
+    await writeTagsMode({ ...props, needSchema: false });
+
+    const operationNamesByBucket = footerSpy.mock.calls.map(
+      ([args]) => args.operationNames,
+    );
+
+    // The untagged op must reach a footer call (the `default` bucket), not be
+    // dropped entirely, and it must not leak into the `pets` bucket.
+    const defaultBucket = operationNamesByBucket.find((names) =>
+      names.includes('getHealth'),
+    );
+    expect(defaultBucket).toEqual(['getHealth']);
+    expect(operationNamesByBucket).toContainEqual(['listPets']);
+  });
+});