genoc 0.1.2 → 0.1.3

package/dist/analyzer/path-analyzer.js

@@ -1,4 +1,5 @@
 import { RefResolver } from '../parser/ref-resolver.js';
+import { sanitizeTypeName } from '../utils/generator-helpers.js';
 import { getMethodName } from './naming.js';
 const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head', 'trace'];
 function isRef(obj) {
@@ -21,7 +22,7 @@ function schemaToTsType(schema, resolver) {
     if (isRef(schema)) {
         const resolved = resolver.resolve(schema);
         const refStr = schema.$ref;
-        const lastSegment = refStr.split('/').pop();
+        const lastSegment = sanitizeTypeName(refStr.split('/').pop());
         if (lastSegment && resolved.type) {
             return lastSegment;
         }

package/dist/analyzer/schema-mapper.js

@@ -1,5 +1,6 @@
 import { RefResolver } from '../parser/ref-resolver.js';
 import { formatToBrandTypeName } from '../utils/case.js';
+import { sanitizeTypeName } from '../utils/generator-helpers.js';
 import { quoteKey } from '../utils/string.js';
 /**
  * Default: extracts the last segment of the JSON pointer.
@@ -7,7 +8,8 @@ import { quoteKey } from '../utils/string.js';
  */
 function defaultTypeNameGenerator(refString) {
     const segments = refString.split('/');
-    return segments[segments.length - 1] || 'unknown';
+    const rawSegment = segments[segments.length - 1] || 'unknown';
+    return sanitizeTypeName(rawSegment);
 }
 function isRefObject(obj) {
     return (obj !== null &&
@@ -230,7 +232,7 @@ export class SchemaMapper {
         }
     }
     resolveDiscriminatorInfo(schema, refStr) {
-        const schemaName = refStr.split('/').pop();
+        const schemaName = sanitizeTypeName(refStr.split('/').pop());
         const target = this.discriminatorTargets.get(schemaName);
         if (target)
             return target;

package/dist/generator/contracts-generator.js

@@ -1,7 +1,7 @@
 import { analyzePaths } from '../analyzer/path-analyzer.js';
 import { SchemaMapper } from '../analyzer/schema-mapper.js';
 import { RefResolver } from '../parser/ref-resolver.js';
-import { toPascalCase, getOperationTypePrefix, makeHeader } from '../utils/generator-helpers.js';
+import { RESERVED_TYPE_NAMES, buildSchemaRenameMap, sanitizeTypeName, toPascalCase, getOperationTypePrefix, makeHeader, } from '../utils/generator-helpers.js';
 function isBinaryContentType(ct) {
     if (ct === 'application/octet-stream')
         return true;
@@ -17,22 +17,24 @@ function isBinaryContentType(ct) {
  * If the schema is a $ref to a discriminated base type (or an array whose items
  * are), replace the type name with the {Base}Variant union type.
  */
-function substituteDiscriminatedType(tsType, schema, discriminatorInfo) {
+function substituteDiscriminatedType(tsType, schema, discriminatorInfo, renameMap) {
     const refSchema = schema;
     if (!refSchema || typeof refSchema !== 'object')
         return tsType;
     if (typeof refSchema.$ref === 'string') {
-        const schemaName = refSchema.$ref.split('/').pop();
+        const schemaName = sanitizeTypeName(refSchema.$ref.split('/').pop());
         if (schemaName && discriminatorInfo.has(schemaName)) {
-            return tsType.replace(new RegExp(`\\b${schemaName}\\b`, 'g'), `${schemaName}Variant`);
+            const renamed = renameMap.get(schemaName) ?? schemaName;
+            return tsType.replace(new RegExp(`\\b${renamed}\\b`, 'g'), `${renamed}Variant`);
         }
     }
     if (refSchema.items && typeof refSchema.items === 'object') {
         const items = refSchema.items;
         if (typeof items.$ref === 'string') {
-            const schemaName = items.$ref.split('/').pop();
+            const schemaName = sanitizeTypeName(items.$ref.split('/').pop());
             if (schemaName && discriminatorInfo.has(schemaName)) {
-                return tsType.replace(new RegExp(`\\b${schemaName}\\b`, 'g'), `${schemaName}Variant`);
+                const renamed = renameMap.get(schemaName) ?? schemaName;
+                return tsType.replace(new RegExp(`\\b${renamed}\\b`, 'g'), `${renamed}Variant`);
             }
         }
     }
@@ -162,6 +164,19 @@ function topologicalSort(entries, allNames) {
  * 7b. UnspecifiedApiError class
  */
 export function generateContracts(doc, resolver) {
+    const schemaNameList = doc.components?.schemas ? Object.keys(doc.components.schemas) : [];
+    const renameMap = buildSchemaRenameMap(schemaNameList, RESERVED_TYPE_NAMES);
+    for (const [original, renamed] of renameMap) {
+        // TODO: Replace with structured logging solution
+        // oxlint-disable-next-line no-console
+        console.warn(`Warning: Schema "${original}" collides with a built-in type and was renamed to "${renamed}".`);
+    }
+    const renamingTypeGenerator = (refString) => {
+        const segments = refString.split('/');
+        const rawSegment = segments[segments.length - 1] || 'unknown';
+        const lastSegment = sanitizeTypeName(rawSegment);
+        return renameMap.get(lastSegment) ?? lastSegment;
+    };
     const discriminatorInfo = new Map();
     if (doc.components?.schemas) {
         for (const [name, schema] of Object.entries(doc.components.schemas)) {
@@ -170,11 +185,12 @@ export function generateContracts(doc, resolver) {
                 const mapping = new Map();
                 if (resolved.discriminator.mapping) {
                     for (const [key, ref] of Object.entries(resolved.discriminator.mapping)) {
-                        const targetName = ref.split('/').pop() || key;
-                        mapping.set(key, targetName);
+                        const targetName = sanitizeTypeName(ref.split('/').pop() || key);
+                        const renamedTarget = renameMap.get(targetName) ?? targetName;
+                        mapping.set(key, renamedTarget);
                     }
                 }
-                discriminatorInfo.set(name, {
+                discriminatorInfo.set(sanitizeTypeName(name), {
                     propertyName: resolved.discriminator.propertyName,
                     mapping,
                 });
@@ -190,25 +206,26 @@ export function generateContracts(doc, resolver) {
             });
         }
     }
-    // reservedNames: prevent branded types from colliding with user-defined schema names
     const allSchemaNames = new Set();
     if (doc.components?.schemas) {
         for (const name of Object.keys(doc.components.schemas)) {
-            allSchemaNames.add(name);
+            allSchemaNames.add(sanitizeTypeName(name));
         }
     }
-    const mapper = new SchemaMapper(resolver, undefined, discriminatorTargets, allSchemaNames);
+    const mapper = new SchemaMapper(resolver, renamingTypeGenerator, discriminatorTargets, allSchemaNames);
     const lines = [];
     lines.push(makeHeader(doc.openapi));
     // Section 1: Schema types
     const schemaEntries = [];
     if (doc.components?.schemas) {
         for (const [name, schema] of Object.entries(doc.components.schemas)) {
-            const result = mapper.mapSchema(schema, name);
+            const sanitizedName = sanitizeTypeName(name);
+            const renamedName = renameMap.get(sanitizedName) ?? sanitizedName;
+            const result = mapper.mapSchema(schema, sanitizedName);
             const resolved = resolver.resolve(schema);
-            const definition = `export type ${name} = ${result.tsType};`;
+            const definition = `export type ${renamedName} = ${result.tsType};`;
             schemaEntries.push({
-                name,
+                name: renamedName,
                 kind: 'type',
                 definition,
                 jsDoc: buildJsDoc(resolved.description),
@@ -228,9 +245,10 @@ export function generateContracts(doc, resolver) {
         if (subtypeNames.length === 0)
             continue;
         const unionType = subtypeNames.join(' | ');
+        const renamedBase = renameMap.get(sanitizeTypeName(baseName)) ?? sanitizeTypeName(baseName);
         lines.push('');
-        lines.push(`export type ${baseName}Variant = ${unionType};`);
-        allSchemaNames.add(`${baseName}Variant`);
+        lines.push(`export type ${renamedBase}Variant = ${unionType};`);
+        allSchemaNames.add(`${renamedBase}Variant`);
     }
     // Section 1b: Security scheme types
     const securitySchemes = doc.components?.securitySchemes;
@@ -376,7 +394,7 @@ export function generateContracts(doc, resolver) {
                     return 'StreamResponse';
                 if (r.schema) {
                     const result = mapper.mapSchema(r.schema, undefined, 'response').tsType;
-                    return substituteDiscriminatedType(result, r.schema, discriminatorInfo);
+                    return substituteDiscriminatedType(result, r.schema, discriminatorInfo, renameMap);
                 }
                 return r.tsType;
             });

package/dist/generator/error-types.d.ts

@@ -15,10 +15,9 @@ export declare class DefaultApiError<TData> extends Error {
  * Produces:
  * 1. `ApiError<TStatus, TData>` class
  * 2. `UnspecifiedApiError` class (extends ApiError, for status codes not in spec)
- * 3. `isError` type guard function
- * 4. Per-operation error union types (e.g. `GetApiV1ProductsErrors`)
- * 5. Per-operation per-status error type aliases (e.g. `GetApiV1ProductsError400`)
- * 6. `DefaultErrorBody` type for `default` responses
- * 7. Catch-all `UnspecifiedApiError` in error unions for unexpected status codes
+ * 3. Per-operation error union types (e.g. `GetApiV1ProductsErrors`)
+ * 4. Per-operation per-status error type aliases (e.g. `GetApiV1ProductsError400`)
+ * 5. `DefaultErrorBody` type for `default` responses
+ * 6. Catch-all `UnspecifiedApiError` in error unions for unexpected status codes
  */
 export declare function generateErrorTypes(operations: AnalyzedOperation[]): string;

package/dist/generator/error-types.js

@@ -24,11 +24,10 @@ export class DefaultApiError extends Error {
  * Produces:
  * 1. `ApiError<TStatus, TData>` class
  * 2. `UnspecifiedApiError` class (extends ApiError, for status codes not in spec)
- * 3. `isError` type guard function
- * 4. Per-operation error union types (e.g. `GetApiV1ProductsErrors`)
- * 5. Per-operation per-status error type aliases (e.g. `GetApiV1ProductsError400`)
- * 6. `DefaultErrorBody` type for `default` responses
- * 7. Catch-all `UnspecifiedApiError` in error unions for unexpected status codes
+ * 3. Per-operation error union types (e.g. `GetApiV1ProductsErrors`)
+ * 4. Per-operation per-status error type aliases (e.g. `GetApiV1ProductsError400`)
+ * 5. `DefaultErrorBody` type for `default` responses
+ * 6. Catch-all `UnspecifiedApiError` in error unions for unexpected status codes
  */
 export function generateErrorTypes(operations) {
     const lines = [];
@@ -54,12 +53,6 @@ export function generateErrorTypes(operations) {
   }
 }`);
     lines.push('');
-    lines.push(`export function isError<T extends { status: number }, S extends number>(
-  response: T,
-  status: S,
-): response is Extract<T, { status: S }> {
-  return response.status === status;
-}`);
     let needsDefaultErrorBody = false;
     for (const op of operations) {
         const errorResponses = op.responses.filter((r) => !r.isSuccess && r.statusCode !== 'default');

package/dist/utils/generator-helpers.d.ts

@@ -1,4 +1,22 @@
 import type { AnalyzedOperation } from '../analyzer/path-analyzer.js';
+/**
+ * Reserved type names used by the generated output's built-in classes,
+ * functions, and types. User-defined schema names that collide with these
+ * are automatically renamed with a suffix to prevent duplicate identifiers.
+ */
+export declare const RESERVED_TYPE_NAMES: ReadonlySet<string>;
+/**
+ * Sanitize a schema type name by converting dot-separated segments into
+ * PascalCase. Names without dots pass through unchanged.
+ *
+ * "Api.Error" → "ApiError", "Simple" → "Simple"
+ */
+export declare function sanitizeTypeName(name: string): string;
+/**
+ * Build a mapping of sanitized schema names → renamed names for any that
+ * collide with reserved type names.
+ */
+export declare function buildSchemaRenameMap(schemaNames: Iterable<string>, reserved: ReadonlySet<string>, suffix?: string): Map<string, string>;
 /**
  * Convert a string to PascalCase, handling camelCase, kebab-case, snake_case,
  * and colon-separated segments.

package/dist/utils/generator-helpers.js

@@ -1,3 +1,55 @@
+/**
+ * Reserved type names used by the generated output's built-in classes,
+ * functions, and types. User-defined schema names that collide with these
+ * are automatically renamed with a suffix to prevent duplicate identifiers.
+ */
+export const RESERVED_TYPE_NAMES = new Set([
+    // Classes in contracts.ts
+    'StreamResponse',
+    'ErrorResponse',
+    'ApiError',
+    'UnspecifiedApiError',
+    'DefaultApiError',
+    'RequesterFailError',
+    // Functions in contracts.ts
+    'streamResponse',
+    'errorResponse',
+    // Types / functions in client.ts
+    'Requester',
+    'isDefinedError',
+    'decorateWithErrors',
+    'ApiClient',
+    // Interface in contracts.ts (when file uploads present)
+    'FileInput',
+]);
+/**
+ * Sanitize a schema type name by converting dot-separated segments into
+ * PascalCase. Names without dots pass through unchanged.
+ *
+ * "Api.Error" → "ApiError", "Simple" → "Simple"
+ */
+export function sanitizeTypeName(name) {
+    if (!name.includes('.'))
+        return name;
+    return name
+        .split('.')
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+}
+/**
+ * Build a mapping of sanitized schema names → renamed names for any that
+ * collide with reserved type names.
+ */
+export function buildSchemaRenameMap(schemaNames, reserved, suffix = 'Model') {
+    const renameMap = new Map();
+    for (const name of schemaNames) {
+        const sanitized = sanitizeTypeName(name);
+        if (reserved.has(sanitized)) {
+            renameMap.set(sanitized, `${sanitized}${suffix}`);
+        }
+    }
+    return renameMap;
+}
 /**
  * Convert a string to PascalCase, handling camelCase, kebab-case, snake_case,
  * and colon-separated segments.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genoc",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Generate typed HTTP clients from OpenAPI 3.0 / 3.1 specifications",
   "keywords": [
     "client",