fix(core): dotted

Author: daugvinasr

packages/core/src/getters/keys.test.ts

@@ -1,8 +1,20 @@
 import { describe, expect, it } from 'vitest';
 
-import { getKey } from './keys';
+import { getKey, getPropertyAccessor } from './keys';
 
 describe('getKey', () => {
+  it('leaves a valid identifier name unchanged', () => {
+    expect(getKey('scopeId')).toBe('scopeId');
+  });
+
+  it('quotes a dotted key', () => {
+    expect(getKey('scope.id')).toBe("'scope.id'");
+  });
+
+  it('quotes a dashed key', () => {
+    expect(getKey('user-id')).toBe("'user-id'");
+  });
+
   it('escapes single quote in key', () => {
     const result = getKey("x':[require('fs').execSync('id'),");
     expect(result).toMatch(/^'(.*)'$/);
@@ -15,3 +27,17 @@ describe('getKey', () => {
     expect(result).toBe(String.raw`'a\\b'`);
   });
 });
+
+describe('getPropertyAccessor', () => {
+  it('uses dot access for a valid identifier name', () => {
+    expect(getPropertyAccessor('scopeId')).toBe('.scopeId');
+  });
+
+  it('uses quoted bracket access for a dotted name', () => {
+    expect(getPropertyAccessor('scope.id')).toBe("['scope.id']");
+  });
+
+  it('escapes quotes inside a bracket-access name', () => {
+    expect(getPropertyAccessor("it's")).toBe(String.raw`['it\'s']`);
+  });
+});

packages/core/src/getters/keys.ts

@@ -7,3 +7,12 @@ export function getKey(key: string) {
     ? key
     : `'${jsStringLiteralEscape(key)}'`;
 }
+
+/**
+ * Emits a property access for a possibly non-identifier name: dot access for
+ * valid identifier names (`.petId`), quoted bracket access otherwise
+ * (`['scope.id']`).
+ */
+export function getPropertyAccessor(name: string) {
+  return keyword.isIdentifierNameES5(name) ? `.${name}` : `[${getKey(name)}]`;
+}

packages/core/src/getters/route.ts

@@ -31,7 +31,47 @@ function runtimeExpressionToUrlPrefix(expression: string): string {
   return '${' + t + '}';
 }
 
-const hasParam = (path: string): boolean => /[^{]*{[\w.*_-]*}.*/.test(path);
+// Characters allowed in an OpenAPI path-parameter name inside `{...}`
+// (`{petId}`, `{user_id}`, `{scope.id}`, `{kebab-case}`, `{path*}`).
+const PATH_PARAM_NAME_CHARS = String.raw`[\w.*_-]`;
+const HAS_PATH_PARAM_REGEX = new RegExp(`[^{]*{${PATH_PARAM_NAME_CHARS}*}.*`);
+const PATH_PARAM_SEGMENT_REGEX = new RegExp(
+  `([^{]*){?(${PATH_PARAM_NAME_CHARS}*)}?(.*)`,
+);
+
+export const hasPathParam = (path: string): boolean =>
+  HAS_PATH_PARAM_REGEX.test(path);
+
+/**
+ * Sanitizes an OpenAPI path-parameter name for emission in generated code:
+ * keeps word characters, underscores, dashes and dots, strips everything
+ * else, and prefixes ES5 keywords with an underscore.
+ */
+export const sanitizePathParamName = (name: string): string =>
+  sanitize(name, { es5keyword: true, underscore: true, dash: true, dot: true });
+
+/**
+ * Converts every `{param}` in a path segment to `:param` (Hono/MSW style
+ * routes). `formatParamName` maps the raw OpenAPI parameter name to the
+ * emitted one (e.g. `sanitizePathParamName`, composed with `camel` or not).
+ */
+export function toColonRoutePath(
+  path: string,
+  formatParamName: (rawName: string) => string,
+): string {
+  const matches = PATH_PARAM_SEGMENT_REGEX.exec(path);
+  if (!matches?.length) return path;
+
+  const [, prev, rawName, rest] = matches;
+  const param = formatParamName(rawName);
+  const next = hasPathParam(rest)
+    ? toColonRoutePath(rest, formatParamName)
+    : rest;
+
+  return hasPathParam(path)
+    ? `${prev}:${param}${next}`
+    : `${prev}${param}${next}`;
+}
 
 const esc = (str: string) => jsesc(str, { quotes: 'backtick', wrap: false });
 
@@ -45,26 +85,21 @@ const getRoutePath = (path: string): string => {
     if (closeIdx === -1) return esc(path);
     const before = esc(path.slice(0, closeIdx + 1));
     const rest = path.slice(closeIdx + 1);
-    return hasParam(rest)
+    return hasPathParam(rest)
       ? `${before}${getRoutePath(rest)}`
       : `${before}${esc(rest)}`;
   }
 
-  const matches = /([^{]*){?([\w.*_-]*)}?(.*)/.exec(path);
+  const matches = PATH_PARAM_SEGMENT_REGEX.exec(path);
   if (!matches?.length) return esc(path);
 
   const prev = matches[1];
   const rawParam = matches[2];
   const rest = matches[3];
-  const param = sanitize(camel(rawParam), {
-    es5keyword: true,
-    underscore: true,
-    dash: true,
-    dot: true,
-  });
-  const next = hasParam(rest) ? getRoutePath(rest) : esc(rest);
-
-  return hasParam(path)
+  const param = sanitizePathParamName(camel(rawParam));
+  const next = hasPathParam(rest) ? getRoutePath(rest) : esc(rest);
+
+  return hasPathParam(path)
     ? `${esc(prev)}\${${param}}${next}`
     : `${esc(prev)}${param}${next}`;
 };

packages/core/src/utils/string.test.ts

@@ -7,27 +7,8 @@ import {
   jsStringEscape,
   jsStringLiteralEscape,
   stringify,
-  toObjectKey,
 } from './string';
 
-describe('toObjectKey', () => {
-  it('leaves a valid identifier name unchanged', () => {
-    expect(toObjectKey('scopeId')).toBe('scopeId');
-  });
-
-  it('quotes a dotted name', () => {
-    expect(toObjectKey('scope.id')).toBe("'scope.id'");
-  });
-
-  it('quotes a dashed name', () => {
-    expect(toObjectKey('user-id')).toBe("'user-id'");
-  });
-
-  it('escapes quotes inside the name', () => {
-    expect(toObjectKey("it's")).toBe(String.raw`'it\'s'`);
-  });
-});
-
 describe('dedupeUnionType', () => {
   describe('edge cases', () => {
     it('should handle empty string', () => {

packages/core/src/utils/string.ts

@@ -321,17 +321,6 @@ export function jsStringLiteralEscape(input: string) {
   });
 }
 
-/**
- * Formats a name for use as an object-literal or type-literal key: returned
- * as-is when it is a valid identifier name, single-quoted (and escaped)
- * otherwise (e.g. `scope.id` → `'scope.id'`).
- */
-export function toObjectKey(name: string): string {
-  return keyword.isIdentifierNameES5(name)
-    ? name
-    : `'${jsStringLiteralEscape(name)}'`;
-}
-
 /**
  * Deduplicates a TypeScript union type string.
  * Handles types like "A | B | B" → "A | B" and "null | null" → "null".

packages/hono/src/index.ts

@@ -24,9 +24,9 @@ import {
   type NormalizedMutator,
   type NormalizedOutputOptions,
   type OpenApiInfoObject,
+  getKey,
   pascal,
   sanitize,
-  toObjectKey,
   getImportExtension,
   type Tsconfig,
   upath,
@@ -736,7 +736,7 @@ const getContext = (verbOption: GeneratorVerbOptions) => {
       const definition = param?.definition.split(':')[1];
       const required = param?.required ?? false;
       return {
-        definition: `${toObjectKey(name)}${required ? '' : '?'}:${definition}`,
+        definition: `${getKey(name)}${required ? '' : '?'}:${definition}`,
       };
     });
     paramType = `param: {\n ${params

packages/hono/src/route.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+
+import { getRoute } from './route';
+
+describe('getRoute getter', () => {
+  // Hono keeps original parameter names (no camelization) so route params
+  // line up with the spec names used by validators and `c.req.param()`.
+  it.each([
+    ['/api/test', '/api/test'],
+    ['/api/test/{id}', '/api/test/:id'],
+    ['/api/test/{path*}', '/api/test/:path'],
+    ['/api/test/{user_id}', '/api/test/:user_id'],
+    ['/api/test/{scope.id}', '/api/test/:scope.id'],
+    [
+      '/api/v1/{scope.id}/items/{item.name}',
+      '/api/v1/:scope.id/items/:item.name',
+    ],
+    ['/api/test/{locale}.js', '/api/test/:locale.js'],
+    ['/api/test/i18n-{locale}.js', '/api/test/i18n-:locale.js'],
+    ['/api/test/{param1}-{param2}.js', '/api/test/:param1-:param2.js'],
+  ])('should process the route %s => %s', (input, expected) => {
+    expect(getRoute(input)).toBe(expected);
+  });
+});

packages/hono/src/route.ts

@@ -1,31 +1,18 @@
-import { sanitize } from '@orval/core';
-
-const hasParam = (path: string): boolean => /[^{]*{[\w.*_-]*}.*/.test(path);
-
-const getRoutePath = (path: string): string => {
-  const matches = /([^{]*){?([\w.*_-]*)}?(.*)/.exec(path);
-  if (!matches?.length) return path; // impossible due to regexp grouping here, but for TS
-
-  const prev = matches[1];
-  const param = sanitize(matches[2], {
-    es5keyword: true,
-    underscore: true,
-    dash: true,
-    dot: true,
-  });
-  const next = hasParam(matches[3]) ? getRoutePath(matches[3]) : matches[3];
-
-  return hasParam(path) ? `${prev}:${param}${next}` : `${prev}${param}${next}`;
-};
+import { sanitizePathParamName, toColonRoutePath } from '@orval/core';
 
+// Hono keeps the original parameter name (no camelization): the `:name` in
+// the route is the key Hono's runtime and validators expose, so it must match
+// the spec's parameter name (e.g. `{scope.id}` → `:scope.id`).
 export const getRoute = (route: string) => {
   const splittedRoute = route.split('/');
 
   let acc = '';
   for (const [i, path] of splittedRoute.entries()) {
     if (!path && i === 0) continue;
 
-    acc += path.includes('{') ? `/${getRoutePath(path)}` : `/${path}`;
+    acc += path.includes('{')
+      ? `/${toColonRoutePath(path, sanitizePathParamName)}`
+      : `/${path}`;
   }
 
   return acc;

packages/mcp/src/index.ts

@@ -19,8 +19,9 @@ import {
   jsStringEscape,
   type NormalizedOutputOptions,
   type OpenApiInfoObject,
+  getKey,
+  getPropertyAccessor,
   pascal,
-  toObjectKey,
   upath,
   type Verbs,
 } from '@orval/core';
@@ -150,7 +151,7 @@ export const generateMcp: ClientBuilder = (verbOptions) => {
     .map((param, index) => {
       const paramName = originalParamNames[index];
       const paramType = param.implementation.split(': ')[1];
-      return `    ${toObjectKey(paramName)}: ${paramType}`;
+      return `    ${getKey(paramName)}: ${paramType}`;
     })
     .join(',\n');
   if (pathParamsType) {
@@ -180,12 +181,7 @@ ${handlerArgsTypes.join('\n')}
   const fetchParams = [];
   if (verbOptions.params.length > 0) {
     const pathParamsArgs = originalParamNames
-      .map((paramName) => {
-        const key = toObjectKey(paramName);
-        return key === paramName
-          ? `args.pathParams.${paramName}`
-          : `args.pathParams[${key}]`;
-      })
+      .map((paramName) => `args.pathParams${getPropertyAccessor(paramName)}`)
       .join(', ');
 
     fetchParams.push(pathParamsArgs);

packages/mock/src/faker/getters/route.ts

@@ -1,22 +1,6 @@
-import { camel, sanitize } from '@orval/core';
+import { camel, sanitizePathParamName, toColonRoutePath } from '@orval/core';
 
-const hasParam = (path: string): boolean => /[^{]*{[\w.*_-]*}.*/.test(path);
-
-const getRoutePath = (path: string): string => {
-  const matches = /([^{]*){?([\w.*_-]*)}?(.*)/.exec(path);
-  if (!matches?.length) return path; // impossible due to regexp grouping here, but for TS
-
-  const prev = matches[1];
-  const param = sanitize(camel(matches[2]), {
-    es5keyword: true,
-    underscore: true,
-    dash: true,
-    dot: true,
-  });
-  const next = hasParam(matches[3]) ? getRoutePath(matches[3]) : matches[3];
-
-  return hasParam(path) ? `${prev}:${param}${next}` : `${prev}${param}${next}`;
-};
+const formatParamName = (name: string) => sanitizePathParamName(camel(name));
 
 export const getRouteMSW = (route: string, baseUrl = '*') => {
   route = route.replaceAll(':', String.raw`\\:`);
@@ -28,12 +12,9 @@ export const getRouteMSW = (route: string, baseUrl = '*') => {
       continue;
     }
 
-    if (!path.includes('{')) {
-      resolvedRoute = `${resolvedRoute}/${path}`;
-      continue;
-    }
-
-    resolvedRoute = `${resolvedRoute}/${getRoutePath(path)}`;
+    resolvedRoute = path.includes('{')
+      ? `${resolvedRoute}/${toColonRoutePath(path, formatParamName)}`
+      : `${resolvedRoute}/${path}`;
   }
 
   return resolvedRoute;