typed-openapi 1.5.0 → 1.5.1

package/dist/chunk-KAEXXJ7X.js

@@ -0,0 +1,21 @@
+// src/format.ts
+import prettier from "prettier";
+import parserTypescript from "prettier/parser-typescript";
+function maybePretty(input, options) {
+  try {
+    return prettier.format(input, {
+      parser: "typescript",
+      plugins: [parserTypescript],
+      ...options
+    });
+  } catch (err) {
+    console.warn("Failed to format code");
+    console.warn(err);
+    return input;
+  }
+}
+var prettify = (str, options) => maybePretty(str, { printWidth: 120, trailingComma: "all", ...options });
+
+export {
+  prettify
+};

package/dist/{chunk-RGFFCU3R.js → chunk-O7DZWQK4.js}

@@ -2,9 +2,11 @@ import {
   allowedRuntimes,
   generateFile,
   generateTanstackQueryFile,
-  mapOpenApiEndpoints,
+  mapOpenApiEndpoints
+} from "./chunk-OVT6OLBK.js";
+import {
   prettify
-} from "./chunk-N6BWPZUB.js";
+} from "./chunk-KAEXXJ7X.js";
 
 // src/generate-client-files.ts
 import SwaggerParser from "@apidevtools/swagger-parser";
@@ -28,13 +30,14 @@ var optionsSchema = type({
 });
 async function generateClientFiles(input, options) {
   const openApiDoc = await SwaggerParser.bundle(input);
-  const ctx = mapOpenApiEndpoints(openApiDoc);
+  const ctx = mapOpenApiEndpoints(openApiDoc, options);
   console.log(`Found ${ctx.endpointList.length} endpoints`);
   const content = await prettify(
     generateFile({
       ...ctx,
       runtime: options.runtime,
-      schemasOnly: options.schemasOnly
+      schemasOnly: options.schemasOnly,
+      nameTransform: options.nameTransform
     })
   );
   const outputPath = join(

package/dist/{chunk-N6BWPZUB.js → chunk-OVT6OLBK.js}

@@ -1,3 +1,7 @@
+import {
+  prettify
+} from "./chunk-KAEXXJ7X.js";
+
 // src/asserts.ts
 var isPrimitiveType = (type2) => primitiveTypeList.includes(type2);
 var primitiveTypeList = ["string", "number", "integer", "boolean", "null"];
@@ -603,10 +607,90 @@ function topologicalSort(graph) {
   return sorted;
 }
 
+// src/sanitize-name.ts
+var reservedWords = /* @__PURE__ */ new Set([
+  // TS keywords and built-ins
+  "import",
+  "package",
+  "namespace",
+  "Record",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "String",
+  "Number",
+  "Boolean",
+  "Object",
+  "Array",
+  "Function",
+  "any",
+  "unknown",
+  "never",
+  "void",
+  "extends",
+  "super",
+  "class",
+  "interface",
+  "type",
+  "enum",
+  "const",
+  "let",
+  "var",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "default",
+  "break",
+  "continue",
+  "return",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "new",
+  "delete",
+  "in",
+  "instanceof",
+  "typeof",
+  "void",
+  "with",
+  "yield",
+  "await",
+  "static",
+  "public",
+  "private",
+  "protected",
+  "abstract",
+  "as",
+  "asserts",
+  "from",
+  "get",
+  "set",
+  "module",
+  "require",
+  "keyof",
+  "readonly",
+  "global",
+  "symbol",
+  "bigint"
+]);
+function sanitizeName(name, type2) {
+  let n = name.replace(/[\W/]+/g, "_");
+  if (/^\d/.test(n)) n = "_" + n;
+  if (reservedWords.has(n)) n = (type2 === "schema" ? "Schema_" : "Endpoint_") + n;
+  return n;
+}
+
 // src/ref-resolver.ts
 var autocorrectRef = (ref) => ref[1] === "/" ? ref : "#/" + ref.slice(1);
 var componentsWithSchemas = ["schemas", "responses", "parameters", "requestBodies", "headers"];
-var createRefResolver = (doc, factory2) => {
+var createRefResolver = (doc, factory2, nameTransform) => {
   const nameByRef = /* @__PURE__ */ new Map();
   const refByName = /* @__PURE__ */ new Map();
   const byRef = /* @__PURE__ */ new Map();
@@ -619,7 +703,11 @@ var createRefResolver = (doc, factory2) => {
     const normalizedPath = path.replace("#/", "").replace("#", "").replaceAll("/", ".");
     const map = get(doc, normalizedPath) ?? {};
     const name = split[split.length - 1];
-    const normalized = normalizeString(name);
+    let normalized = normalizeString(name);
+    if (nameTransform?.transformSchemaName) {
+      normalized = nameTransform.transformSchemaName(normalized);
+    }
+    normalized = sanitizeName(normalized, "schema");
     nameByRef.set(correctRef, normalized);
     refByName.set(normalized, correctRef);
     const infos = { ref: correctRef, name, normalized, kind: normalizedPath.split(".")[1] };
@@ -768,7 +856,7 @@ var tsFactory = createFactory({
 import { capitalize as capitalize3, pick } from "pastable/server";
 import { match as match2, P } from "ts-pattern";
 var factory = tsFactory;
-var mapOpenApiEndpoints = (doc) => {
+var mapOpenApiEndpoints = (doc, options) => {
   const refs = createRefResolver(doc, factory);
   const ctx = { refs, factory };
   const endpointList = [];
@@ -776,6 +864,10 @@ var mapOpenApiEndpoints = (doc) => {
     const pathItem = pick(pathItemObj, ["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
     Object.entries(pathItem).forEach(([method, operation]) => {
       if (operation.deprecated) return;
+      let alias = getAlias({ path, method, operation });
+      if (options?.nameTransform?.transformEndpointName) {
+        alias = options.nameTransform.transformEndpointName({ alias, path, method, operation });
+      }
       const endpoint = {
         operation,
         method,
@@ -783,7 +875,7 @@ var mapOpenApiEndpoints = (doc) => {
         requestFormat: "json",
         response: openApiSchemaToTs({ schema: {}, ctx }),
         meta: {
-          alias: getAlias({ path, method, operation }),
+          alias,
           areParametersRequired: false,
           hasParameters: false
         }
@@ -827,7 +919,7 @@ var mapOpenApiEndpoints = (doc) => {
         const matchingMediaType = Object.keys(content2).find(isAllowedParamMediaTypes);
         if (matchingMediaType && content2[matchingMediaType]) {
           params.body = openApiSchemaToTs({
-            schema: content2[matchingMediaType]?.schema ?? {} ?? {},
+            schema: content2[matchingMediaType]?.schema ?? {},
             ctx
           });
         }
@@ -866,7 +958,7 @@ var mapOpenApiEndpoints = (doc) => {
         const matchingMediaType = Object.keys(content).find(isResponseMediaType);
         if (matchingMediaType && content[matchingMediaType]) {
           endpoint.response = openApiSchemaToTs({
-            schema: content[matchingMediaType]?.schema ?? {} ?? {},
+            schema: content[matchingMediaType]?.schema ?? {},
             ctx
           });
         }
@@ -895,25 +987,10 @@ var allowedParamMediaTypes = [
 ];
 var isAllowedParamMediaTypes = (mediaType) => mediaType.includes("application/") && mediaType.includes("json") || allowedParamMediaTypes.includes(mediaType) || mediaType.includes("text/");
 var isResponseMediaType = (mediaType) => mediaType === "application/json";
-var getAlias = ({ path, method, operation }) => (method + "_" + capitalize3(operation.operationId ?? pathToVariableName(path))).replace(/-/g, "__");
-
-// src/format.ts
-import prettier from "prettier";
-import parserTypescript from "prettier/parser-typescript";
-function maybePretty(input, options) {
-  try {
-    return prettier.format(input, {
-      parser: "typescript",
-      plugins: [parserTypescript],
-      ...options
-    });
-  } catch (err) {
-    console.warn("Failed to format code");
-    console.warn(err);
-    return input;
-  }
-}
-var prettify = (str, options) => maybePretty(str, { printWidth: 120, trailingComma: "all", ...options });
+var getAlias = ({ path, method, operation }) => sanitizeName(
+  (method + "_" + capitalize3(operation.operationId ?? pathToVariableName(path))).replace(/-/g, "__"),
+  "endpoint"
+);
 
 // src/tanstack-query.generator.ts
 import { capitalize as capitalize4 } from "pastable/server";
@@ -1064,6 +1141,5 @@ export {
   createRefResolver,
   tsFactory,
   mapOpenApiEndpoints,
-  prettify,
   generateTanstackQueryFile
 };

package/dist/cli.js

@@ -1,9 +1,10 @@
 import {
   generateClientFiles
-} from "./chunk-RGFFCU3R.js";
+} from "./chunk-O7DZWQK4.js";
 import {
   allowedRuntimes
-} from "./chunk-N6BWPZUB.js";
+} from "./chunk-OVT6OLBK.js";
+import "./chunk-KAEXXJ7X.js";
 
 // src/cli.ts
 import { cac } from "cac";

package/dist/index.d.ts

@@ -1,176 +1,9 @@
-import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
-import { OpenAPIObject, ReferenceObject, SchemaObject, OperationObject } from 'openapi3-ts/oas31';
-import { SchemaObject as SchemaObject$1 } from 'openapi3-ts/oas30';
+import { ReferenceObject } from 'openapi3-ts/oas31';
+import { S as StringOrBox, O as OpenapiSchemaConvertContext, L as LibSchemaObject, B as BoxFactory, m as mapOpenApiEndpoints, N as NameTransformOptions, a as OpenapiSchemaConvertArgs, b as Box, A as AnyBoxDef } from './types-DLE5RaXi.js';
+export { q as AnyBox, j as BoxArray, f as BoxDefinition, i as BoxIntersection, o as BoxKeyword, n as BoxLiteral, p as BoxObject, k as BoxOptional, g as BoxParams, l as BoxRef, h as BoxUnion, c as Endpoint, E as EndpointParameters, F as FactoryCreator, G as GenericFactory, M as Method, R as RefInfo, e as RefResolver, W as WithSchema, d as createRefResolver } from './types-DLE5RaXi.js';
 import * as arktype_internal_methods_string_ts from 'arktype/internal/methods/string.ts';
 import * as Codegen from '@sinclair/typebox-codegen';
-
-declare class Box<T extends AnyBoxDef = AnyBoxDef> {
-    definition: T;
-    type: T["type"];
-    value: T["value"];
-    params: T["params"];
-    schema: T["schema"];
-    ctx: T["ctx"];
-    constructor(definition: T);
-    toJSON(): {
-        type: T["type"];
-        value: T["value"];
-    };
-    toString(): string;
-    recompute(callback: OpenapiSchemaConvertContext["onBox"]): Box<AnyBoxDef>;
-    static fromJSON(json: string): Box<any>;
-    static isBox(box: unknown): box is Box<AnyBoxDef>;
-    static isUnion(box: Box<AnyBoxDef>): box is Box<BoxUnion>;
-    static isIntersection(box: Box<AnyBoxDef>): box is Box<BoxIntersection>;
-    static isArray(box: Box<AnyBoxDef>): box is Box<BoxArray>;
-    static isOptional(box: Box<AnyBoxDef>): box is Box<BoxOptional>;
-    static isReference(box: Box<AnyBoxDef>): box is Box<BoxRef>;
-    static isKeyword(box: Box<AnyBoxDef>): box is Box<BoxKeyword>;
-    static isObject(box: Box<AnyBoxDef>): box is Box<BoxObject>;
-    static isLiteral(box: Box<AnyBoxDef>): box is Box<BoxLiteral>;
-}
-
-type RefInfo = {
-    /**
-     * The (potentially autocorrected) ref
-     * @example "#/components/schemas/MySchema"
-     */
-    ref: string;
-    /**
-     * The name of the ref
-     * @example "MySchema"
-     * */
-    name: string;
-    normalized: string;
-    kind: "schemas" | "responses" | "parameters" | "requestBodies" | "headers";
-};
-declare const createRefResolver: (doc: OpenAPIObject, factory: GenericFactory) => {
-    get: <T = LibSchemaObject>(ref: string) => NonNullable<T>;
-    unwrap: <T extends ReferenceObject | {}>(component: T) => Exclude<T, ReferenceObject>;
-    getInfosByRef: (ref: string) => RefInfo;
-    infos: Map<string, RefInfo>;
-    /**
-     * Get the schemas in the order they should be generated, depending on their dependencies
-     * so that a schema is generated before the ones that depend on it
-     */
-    getOrderedSchemas: () => [schema: Box<AnyBoxDef>, infos: RefInfo][];
-    directDependencies: Map<string, Set<string>>;
-    transitiveDependencies: Map<string, Set<string>>;
-};
-interface RefResolver extends ReturnType<typeof createRefResolver> {
-}
-
-type LibSchemaObject = SchemaObject & SchemaObject$1;
-type BoxDefinition = {
-    type: string;
-    params: unknown;
-    value: string;
-};
-type BoxParams = string | BoxDefinition;
-type WithSchema = {
-    schema: LibSchemaObject | ReferenceObject | undefined;
-    ctx: OpenapiSchemaConvertContext;
-};
-type BoxUnion = WithSchema & {
-    type: "union";
-    params: {
-        types: Array<BoxParams>;
-    };
-    value: string;
-};
-type BoxIntersection = WithSchema & {
-    type: "intersection";
-    params: {
-        types: Array<BoxParams>;
-    };
-    value: string;
-};
-type BoxArray = WithSchema & {
-    type: "array";
-    params: {
-        type: BoxParams;
-    };
-    value: string;
-};
-type BoxOptional = WithSchema & {
-    type: "optional";
-    params: {
-        type: BoxParams;
-    };
-    value: string;
-};
-type BoxRef = WithSchema & {
-    type: "ref";
-    params: {
-        name: string;
-        generics?: BoxParams[] | undefined;
-    };
-    value: string;
-};
-type BoxLiteral = WithSchema & {
-    type: "literal";
-    params: {};
-    value: string;
-};
-type BoxKeyword = WithSchema & {
-    type: "keyword";
-    params: {
-        name: string;
-    };
-    value: string;
-};
-type BoxObject = WithSchema & {
-    type: "object";
-    params: {
-        props: Record<string, BoxParams>;
-    };
-    value: string;
-};
-type AnyBoxDef = BoxUnion | BoxIntersection | BoxArray | BoxOptional | BoxRef | BoxLiteral | BoxKeyword | BoxObject;
-type AnyBox = Box<AnyBoxDef>;
-type OpenapiSchemaConvertArgs = {
-    schema: SchemaObject | ReferenceObject;
-    ctx: OpenapiSchemaConvertContext;
-    meta?: {} | undefined;
-};
-type FactoryCreator = (schema: SchemaObject | ReferenceObject, ctx: OpenapiSchemaConvertContext) => GenericFactory;
-type OpenapiSchemaConvertContext = {
-    factory: FactoryCreator | GenericFactory;
-    refs: RefResolver;
-    onBox?: (box: Box<AnyBoxDef>) => Box<AnyBoxDef>;
-};
-type StringOrBox = string | Box<AnyBoxDef>;
-type BoxFactory = {
-    union: (types: Array<StringOrBox>) => Box<BoxUnion>;
-    intersection: (types: Array<StringOrBox>) => Box<BoxIntersection>;
-    array: (type: StringOrBox) => Box<BoxArray>;
-    object: (props: Record<string, StringOrBox>) => Box<BoxObject>;
-    optional: (type: StringOrBox) => Box<BoxOptional>;
-    reference: (name: string, generics?: Array<StringOrBox> | undefined) => Box<BoxRef>;
-    literal: (value: StringOrBox) => Box<BoxLiteral>;
-    string: () => Box<BoxKeyword>;
-    number: () => Box<BoxKeyword>;
-    boolean: () => Box<BoxKeyword>;
-    unknown: () => Box<BoxKeyword>;
-    any: () => Box<BoxKeyword>;
-    never: () => Box<BoxKeyword>;
-};
-type GenericFactory = {
-    callback?: OpenapiSchemaConvertContext["onBox"];
-    union: (types: Array<StringOrBox>) => string;
-    intersection: (types: Array<StringOrBox>) => string;
-    array: (type: StringOrBox) => string;
-    object: (props: Record<string, StringOrBox>) => string;
-    optional: (type: StringOrBox) => string;
-    reference: (name: string, generics?: Array<StringOrBox> | undefined) => string;
-    literal: (value: StringOrBox) => string;
-    string: () => string;
-    number: () => string;
-    boolean: () => string;
-    unknown: () => string;
-    any: () => string;
-    never: () => string;
-};
+import 'openapi3-ts/oas30';
 
 declare const unwrap: (param: StringOrBox) => string;
 declare const createFactory: <T extends OpenapiSchemaConvertContext["factory"]>(f: T) => T;
@@ -179,66 +12,10 @@ declare const createFactory: <T extends OpenapiSchemaConvertContext["factory"]>(
  */
 declare const createBoxFactory: (schema: LibSchemaObject | ReferenceObject, ctx: OpenapiSchemaConvertContext) => BoxFactory;
 
-declare const mapOpenApiEndpoints: (doc: OpenAPIObject) => {
-    doc: OpenAPIObject;
-    refs: {
-        get: <T = LibSchemaObject>(ref: string) => NonNullable<T>;
-        unwrap: <T extends openapi3_ts_oas31.ReferenceObject | {}>(component: T) => Exclude<T, openapi3_ts_oas31.ReferenceObject>;
-        getInfosByRef: (ref: string) => RefInfo;
-        infos: Map<string, RefInfo>;
-        getOrderedSchemas: () => [schema: Box<AnyBoxDef>, infos: RefInfo][];
-        directDependencies: Map<string, Set<string>>;
-        transitiveDependencies: Map<string, Set<string>>;
-    };
-    endpointList: Endpoint<DefaultEndpoint>[];
-    factory: {
-        union: (types: StringOrBox[]) => string;
-        intersection: (types: StringOrBox[]) => string;
-        array: (type: StringOrBox) => string;
-        optional: (type: StringOrBox) => string;
-        reference: (name: string, typeArgs: StringOrBox[] | undefined) => string;
-        literal: (value: StringOrBox) => string;
-        string: () => "string";
-        number: () => "number";
-        boolean: () => "boolean";
-        unknown: () => "unknown";
-        any: () => "any";
-        never: () => "never";
-        object: (props: Record<string, StringOrBox>) => string;
-    };
-};
-type MutationMethod = "post" | "put" | "patch" | "delete";
-type Method = "get" | "head" | "options" | MutationMethod;
-type EndpointParameters = {
-    body?: Box<BoxRef>;
-    query?: Box<BoxRef> | Record<string, AnyBox>;
-    header?: Box<BoxRef> | Record<string, AnyBox>;
-    path?: Box<BoxRef> | Record<string, AnyBox>;
-};
-type RequestFormat = "json" | "form-data" | "form-url" | "binary" | "text";
-type DefaultEndpoint = {
-    parameters?: EndpointParameters | undefined;
-    response: AnyBox;
-    responseHeaders?: Record<string, AnyBox>;
-};
-type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
-    operation: OperationObject;
-    method: Method;
-    path: string;
-    parameters?: TConfig["parameters"];
-    requestFormat: RequestFormat;
-    meta: {
-        alias: string;
-        hasParameters: boolean;
-        areParametersRequired: boolean;
-    };
-    response: TConfig["response"];
-    responseHeaders?: TConfig["responseHeaders"];
-};
-
 type GeneratorOptions$1 = ReturnType<typeof mapOpenApiEndpoints> & {
     runtime?: "none" | keyof typeof runtimeValidationGenerator;
     schemasOnly?: boolean;
+    nameTransform?: NameTransformOptions | undefined;
 };
 declare const allowedRuntimes: arktype_internal_methods_string_ts.StringType<"none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod", {}>;
 type OutputRuntime = typeof allowedRuntimes.infer;
@@ -276,4 +53,4 @@ declare const tsFactory: {
     object: (props: Record<string, StringOrBox>) => string;
 };
 
-export { type AnyBox, type AnyBoxDef, type BoxArray, type BoxDefinition, type BoxFactory, type BoxIntersection, type BoxKeyword, type BoxLiteral, type BoxObject, type BoxOptional, type BoxParams, type BoxRef, type BoxUnion, type Endpoint, type EndpointParameters, type FactoryCreator, type GenericFactory, type LibSchemaObject, type OpenapiSchemaConvertArgs, type OpenapiSchemaConvertContext, type OutputRuntime, type RefInfo, type RefResolver, type StringOrBox, type WithSchema, createBoxFactory, createFactory, createRefResolver, generateFile, generateTanstackQueryFile, mapOpenApiEndpoints, openApiSchemaToTs, tsFactory, unwrap };
+export { AnyBoxDef, BoxFactory, LibSchemaObject, NameTransformOptions, OpenapiSchemaConvertArgs, OpenapiSchemaConvertContext, type OutputRuntime, StringOrBox, createBoxFactory, createFactory, generateFile, generateTanstackQueryFile, mapOpenApiEndpoints, openApiSchemaToTs, tsFactory, unwrap };

package/dist/index.js

@@ -8,7 +8,8 @@ import {
   openApiSchemaToTs,
   tsFactory,
   unwrap
-} from "./chunk-N6BWPZUB.js";
+} from "./chunk-OVT6OLBK.js";
+import "./chunk-KAEXXJ7X.js";
 export {
   createBoxFactory,
   createFactory,

package/dist/node.export.d.ts

@@ -1,7 +1,7 @@
-import { Options } from 'prettier';
 import * as arktype_internal_methods_object_ts from 'arktype/internal/methods/object.ts';
-
-declare const prettify: (str: string, options?: Options | null) => string | Promise<string>;
+import { N as NameTransformOptions } from './types-DLE5RaXi.js';
+import 'openapi3-ts/oas31';
+import 'openapi3-ts/oas30';
 
 declare const optionsSchema: arktype_internal_methods_object_ts.ObjectType<{
     runtime: "none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod";
@@ -9,6 +9,9 @@ declare const optionsSchema: arktype_internal_methods_object_ts.ObjectType<{
     schemasOnly: boolean;
     output?: string;
 }, {}>;
-declare function generateClientFiles(input: string, options: typeof optionsSchema.infer): Promise<void>;
+type GenerateClientFilesOptions = typeof optionsSchema.infer & {
+    nameTransform?: NameTransformOptions;
+};
+declare function generateClientFiles(input: string, options: GenerateClientFilesOptions): Promise<void>;
 
-export { generateClientFiles, prettify };
+export { generateClientFiles };

package/dist/node.export.js

@@ -1,10 +1,8 @@
 import {
   generateClientFiles
-} from "./chunk-RGFFCU3R.js";
-import {
-  prettify
-} from "./chunk-N6BWPZUB.js";
+} from "./chunk-O7DZWQK4.js";
+import "./chunk-OVT6OLBK.js";
+import "./chunk-KAEXXJ7X.js";
 export {
-  generateClientFiles,
-  prettify
+  generateClientFiles
 };

package/dist/pretty.export.d.ts

@@ -0,0 +1,5 @@
+import { Options } from 'prettier';
+
+declare const prettify: (str: string, options?: Options | null) => string | Promise<string>;
+
+export { prettify };

package/dist/pretty.export.js

@@ -0,0 +1,6 @@
+import {
+  prettify
+} from "./chunk-KAEXXJ7X.js";
+export {
+  prettify
+};

package/dist/types-DLE5RaXi.d.ts

@@ -0,0 +1,242 @@
+import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
+import { OpenAPIObject, ReferenceObject, OperationObject, SchemaObject } from 'openapi3-ts/oas31';
+import { SchemaObject as SchemaObject$1 } from 'openapi3-ts/oas30';
+
+declare class Box<T extends AnyBoxDef = AnyBoxDef> {
+    definition: T;
+    type: T["type"];
+    value: T["value"];
+    params: T["params"];
+    schema: T["schema"];
+    ctx: T["ctx"];
+    constructor(definition: T);
+    toJSON(): {
+        type: T["type"];
+        value: T["value"];
+    };
+    toString(): string;
+    recompute(callback: OpenapiSchemaConvertContext["onBox"]): Box<AnyBoxDef>;
+    static fromJSON(json: string): Box<any>;
+    static isBox(box: unknown): box is Box<AnyBoxDef>;
+    static isUnion(box: Box<AnyBoxDef>): box is Box<BoxUnion>;
+    static isIntersection(box: Box<AnyBoxDef>): box is Box<BoxIntersection>;
+    static isArray(box: Box<AnyBoxDef>): box is Box<BoxArray>;
+    static isOptional(box: Box<AnyBoxDef>): box is Box<BoxOptional>;
+    static isReference(box: Box<AnyBoxDef>): box is Box<BoxRef>;
+    static isKeyword(box: Box<AnyBoxDef>): box is Box<BoxKeyword>;
+    static isObject(box: Box<AnyBoxDef>): box is Box<BoxObject>;
+    static isLiteral(box: Box<AnyBoxDef>): box is Box<BoxLiteral>;
+}
+
+type RefInfo = {
+    /**
+     * The (potentially autocorrected) ref
+     * @example "#/components/schemas/MySchema"
+     */
+    ref: string;
+    /**
+     * The name of the ref
+     * @example "MySchema"
+     * */
+    name: string;
+    normalized: string;
+    kind: "schemas" | "responses" | "parameters" | "requestBodies" | "headers";
+};
+declare const createRefResolver: (doc: OpenAPIObject, factory: GenericFactory, nameTransform?: NameTransformOptions) => {
+    get: <T = LibSchemaObject>(ref: string) => NonNullable<T>;
+    unwrap: <T extends ReferenceObject | {}>(component: T) => Exclude<T, ReferenceObject>;
+    getInfosByRef: (ref: string) => RefInfo;
+    infos: Map<string, RefInfo>;
+    /**
+     * Get the schemas in the order they should be generated, depending on their dependencies
+     * so that a schema is generated before the ones that depend on it
+     */
+    getOrderedSchemas: () => [schema: Box<AnyBoxDef>, infos: RefInfo][];
+    directDependencies: Map<string, Set<string>>;
+    transitiveDependencies: Map<string, Set<string>>;
+};
+interface RefResolver extends ReturnType<typeof createRefResolver> {
+}
+
+declare const mapOpenApiEndpoints: (doc: OpenAPIObject, options?: {
+    nameTransform?: NameTransformOptions;
+}) => {
+    doc: OpenAPIObject;
+    refs: {
+        get: <T = LibSchemaObject>(ref: string) => NonNullable<T>;
+        unwrap: <T extends openapi3_ts_oas31.ReferenceObject | {}>(component: T) => Exclude<T, openapi3_ts_oas31.ReferenceObject>;
+        getInfosByRef: (ref: string) => RefInfo;
+        infos: Map<string, RefInfo>;
+        getOrderedSchemas: () => [schema: Box<AnyBoxDef>, infos: RefInfo][];
+        directDependencies: Map<string, Set<string>>;
+        transitiveDependencies: Map<string, Set<string>>;
+    };
+    endpointList: Endpoint<DefaultEndpoint>[];
+    factory: {
+        union: (types: StringOrBox[]) => string;
+        intersection: (types: StringOrBox[]) => string;
+        array: (type: StringOrBox) => string;
+        optional: (type: StringOrBox) => string;
+        reference: (name: string, typeArgs: StringOrBox[] | undefined) => string;
+        literal: (value: StringOrBox) => string;
+        string: () => "string";
+        number: () => "number";
+        boolean: () => "boolean";
+        unknown: () => "unknown";
+        any: () => "any";
+        never: () => "never";
+        object: (props: Record<string, StringOrBox>) => string;
+    };
+};
+type MutationMethod = "post" | "put" | "patch" | "delete";
+type Method = "get" | "head" | "options" | MutationMethod;
+type EndpointParameters = {
+    body?: Box<BoxRef>;
+    query?: Box<BoxRef> | Record<string, AnyBox>;
+    header?: Box<BoxRef> | Record<string, AnyBox>;
+    path?: Box<BoxRef> | Record<string, AnyBox>;
+};
+type RequestFormat = "json" | "form-data" | "form-url" | "binary" | "text";
+type DefaultEndpoint = {
+    parameters?: EndpointParameters | undefined;
+    response: AnyBox;
+    responseHeaders?: Record<string, AnyBox>;
+};
+type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
+    operation: OperationObject;
+    method: Method;
+    path: string;
+    parameters?: TConfig["parameters"];
+    requestFormat: RequestFormat;
+    meta: {
+        alias: string;
+        hasParameters: boolean;
+        areParametersRequired: boolean;
+    };
+    response: TConfig["response"];
+    responseHeaders?: TConfig["responseHeaders"];
+};
+
+type LibSchemaObject = SchemaObject & SchemaObject$1;
+type BoxDefinition = {
+    type: string;
+    params: unknown;
+    value: string;
+};
+type BoxParams = string | BoxDefinition;
+type WithSchema = {
+    schema: LibSchemaObject | ReferenceObject | undefined;
+    ctx: OpenapiSchemaConvertContext;
+};
+type BoxUnion = WithSchema & {
+    type: "union";
+    params: {
+        types: Array<BoxParams>;
+    };
+    value: string;
+};
+type BoxIntersection = WithSchema & {
+    type: "intersection";
+    params: {
+        types: Array<BoxParams>;
+    };
+    value: string;
+};
+type BoxArray = WithSchema & {
+    type: "array";
+    params: {
+        type: BoxParams;
+    };
+    value: string;
+};
+type BoxOptional = WithSchema & {
+    type: "optional";
+    params: {
+        type: BoxParams;
+    };
+    value: string;
+};
+type BoxRef = WithSchema & {
+    type: "ref";
+    params: {
+        name: string;
+        generics?: BoxParams[] | undefined;
+    };
+    value: string;
+};
+type BoxLiteral = WithSchema & {
+    type: "literal";
+    params: {};
+    value: string;
+};
+type BoxKeyword = WithSchema & {
+    type: "keyword";
+    params: {
+        name: string;
+    };
+    value: string;
+};
+type BoxObject = WithSchema & {
+    type: "object";
+    params: {
+        props: Record<string, BoxParams>;
+    };
+    value: string;
+};
+type AnyBoxDef = BoxUnion | BoxIntersection | BoxArray | BoxOptional | BoxRef | BoxLiteral | BoxKeyword | BoxObject;
+type AnyBox = Box<AnyBoxDef>;
+type OpenapiSchemaConvertArgs = {
+    schema: SchemaObject | ReferenceObject;
+    ctx: OpenapiSchemaConvertContext;
+    meta?: {} | undefined;
+};
+type FactoryCreator = (schema: SchemaObject | ReferenceObject, ctx: OpenapiSchemaConvertContext) => GenericFactory;
+type NameTransformOptions = {
+    transformSchemaName?: (name: string) => string;
+    transformEndpointName?: (endpoint: {
+        alias: string;
+        operation: OperationObject;
+        method: Method;
+        path: string;
+    }) => string;
+};
+type OpenapiSchemaConvertContext = {
+    factory: FactoryCreator | GenericFactory;
+    refs: RefResolver;
+    onBox?: (box: Box<AnyBoxDef>) => Box<AnyBoxDef>;
+    nameTransform?: NameTransformOptions;
+};
+type StringOrBox = string | Box<AnyBoxDef>;
+type BoxFactory = {
+    union: (types: Array<StringOrBox>) => Box<BoxUnion>;
+    intersection: (types: Array<StringOrBox>) => Box<BoxIntersection>;
+    array: (type: StringOrBox) => Box<BoxArray>;
+    object: (props: Record<string, StringOrBox>) => Box<BoxObject>;
+    optional: (type: StringOrBox) => Box<BoxOptional>;
+    reference: (name: string, generics?: Array<StringOrBox> | undefined) => Box<BoxRef>;
+    literal: (value: StringOrBox) => Box<BoxLiteral>;
+    string: () => Box<BoxKeyword>;
+    number: () => Box<BoxKeyword>;
+    boolean: () => Box<BoxKeyword>;
+    unknown: () => Box<BoxKeyword>;
+    any: () => Box<BoxKeyword>;
+    never: () => Box<BoxKeyword>;
+};
+type GenericFactory = {
+    callback?: OpenapiSchemaConvertContext["onBox"];
+    union: (types: Array<StringOrBox>) => string;
+    intersection: (types: Array<StringOrBox>) => string;
+    array: (type: StringOrBox) => string;
+    object: (props: Record<string, StringOrBox>) => string;
+    optional: (type: StringOrBox) => string;
+    reference: (name: string, generics?: Array<StringOrBox> | undefined) => string;
+    literal: (value: StringOrBox) => string;
+    string: () => string;
+    number: () => string;
+    boolean: () => string;
+    unknown: () => string;
+    any: () => string;
+    never: () => string;
+};
+
+export { type AnyBoxDef as A, type BoxFactory as B, type EndpointParameters as E, type FactoryCreator as F, type GenericFactory as G, type LibSchemaObject as L, type Method as M, type NameTransformOptions as N, type OpenapiSchemaConvertContext as O, type RefInfo as R, type StringOrBox as S, type WithSchema as W, type OpenapiSchemaConvertArgs as a, Box as b, type Endpoint as c, createRefResolver as d, type RefResolver as e, type BoxDefinition as f, type BoxParams as g, type BoxUnion as h, type BoxIntersection as i, type BoxArray as j, type BoxOptional as k, type BoxRef as l, mapOpenApiEndpoints as m, type BoxLiteral as n, type BoxKeyword as o, type BoxObject as p, type AnyBox as q };

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "typed-openapi",
   "type": "module",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",
-    "./node": "./dist/node.export.js"
+    "./node": "./dist/node.export.js",
+    "./pretty": "./dist/pretty.export.js"
   },
   "bin": {
     "typed-openapi": "bin.js"

package/src/generate-client-files.ts

@@ -7,6 +7,7 @@ import { allowedRuntimes, generateFile } from "./generator.ts";
 import { mapOpenApiEndpoints } from "./map-openapi-endpoints.ts";
 import { generateTanstackQueryFile } from "./tanstack-query.generator.ts";
 import { prettify } from "./format.ts";
+import type { NameTransformOptions } from "./types.ts";
 
 const cwd = process.cwd();
 const now = new Date();
@@ -26,10 +27,14 @@ export const optionsSchema = type({
   schemasOnly: "boolean",
 });
 
-export async function generateClientFiles(input: string, options: typeof optionsSchema.infer) {
+type GenerateClientFilesOptions = typeof optionsSchema.infer & {
+  nameTransform?: NameTransformOptions;
+};
+
+export async function generateClientFiles(input: string, options: GenerateClientFilesOptions) {
   const openApiDoc = (await SwaggerParser.bundle(input)) as OpenAPIObject;
 
-  const ctx = mapOpenApiEndpoints(openApiDoc);
+  const ctx = mapOpenApiEndpoints(openApiDoc, options);
   console.log(`Found ${ctx.endpointList.length} endpoints`);
 
   const content = await prettify(
@@ -37,6 +42,7 @@ export async function generateClientFiles(input: string, options: typeof options
       ...ctx,
       runtime: options.runtime,
       schemasOnly: options.schemasOnly,
+      nameTransform: options.nameTransform,
     }),
   );
   const outputPath = join(

package/src/generator.ts

@@ -6,10 +6,12 @@ import * as Codegen from "@sinclair/typebox-codegen";
 import { match } from "ts-pattern";
 import { type } from "arktype";
 import { wrapWithQuotesIfNeeded } from "./string-utils.ts";
+import type { NameTransformOptions } from "./types.ts";
 
 type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints> & {
   runtime?: "none" | keyof typeof runtimeValidationGenerator;
   schemasOnly?: boolean;
+  nameTransform?: NameTransformOptions | undefined;
 };
 type GeneratorContext = Required<GeneratorOptions>;
 

package/src/map-openapi-endpoints.ts

@@ -8,11 +8,13 @@ import { createRefResolver } from "./ref-resolver.ts";
 import { tsFactory } from "./ts-factory.ts";
 import { AnyBox, BoxRef, OpenapiSchemaConvertContext } from "./types.ts";
 import { pathToVariableName } from "./string-utils.ts";
+import { NameTransformOptions } from "./types.ts";
 import { match, P } from "ts-pattern";
+import { sanitizeName } from "./sanitize-name.ts";
 
 const factory = tsFactory;
 
-export const mapOpenApiEndpoints = (doc: OpenAPIObject) => {
+export const mapOpenApiEndpoints = (doc: OpenAPIObject, options?: { nameTransform?: NameTransformOptions }) => {
   const refs = createRefResolver(doc, factory);
   const ctx: OpenapiSchemaConvertContext = { refs, factory };
   const endpointList = [] as Array<Endpoint>;
@@ -22,6 +24,10 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject) => {
     Object.entries(pathItem).forEach(([method, operation]) => {
       if (operation.deprecated) return;
 
+      let alias = getAlias({ path, method, operation } as Endpoint);
+      if (options?.nameTransform?.transformEndpointName) {
+        alias = options.nameTransform.transformEndpointName({ alias, path, method: method as Method, operation });
+      }
       const endpoint = {
         operation,
         method: method as Method,
@@ -29,7 +35,7 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject) => {
         requestFormat: "json",
         response: openApiSchemaToTs({ schema: {}, ctx }),
         meta: {
-          alias: getAlias({ path, method, operation } as Endpoint),
+          alias,
           areParametersRequired: false,
           hasParameters: false,
         },
@@ -84,7 +90,7 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject) => {
 
         if (matchingMediaType && content[matchingMediaType]) {
           params.body = openApiSchemaToTs({
-            schema: content[matchingMediaType]?.schema ?? {} ?? {},
+            schema: content[matchingMediaType]?.schema ?? {},
             ctx,
           });
         }
@@ -139,7 +145,7 @@ export const mapOpenApiEndpoints = (doc: OpenAPIObject) => {
         const matchingMediaType = Object.keys(content).find(isResponseMediaType);
         if (matchingMediaType && content[matchingMediaType]) {
           endpoint.response = openApiSchemaToTs({
-            schema: content[matchingMediaType]?.schema ?? {} ?? {},
+            schema: content[matchingMediaType]?.schema ?? {},
             ctx,
           });
         }
@@ -180,10 +186,13 @@ const isAllowedParamMediaTypes = (
 
 const isResponseMediaType = (mediaType: string) => mediaType === "application/json";
 const getAlias = ({ path, method, operation }: Endpoint) =>
-  (method + "_" + capitalize(operation.operationId ?? pathToVariableName(path))).replace(/-/g, "__");
+  sanitizeName(
+    (method + "_" + capitalize(operation.operationId ?? pathToVariableName(path))).replace(/-/g, "__"),
+    "endpoint",
+  );
 
 type MutationMethod = "post" | "put" | "patch" | "delete";
-type Method = "get" | "head" | "options" | MutationMethod;
+export type Method = "get" | "head" | "options" | MutationMethod;
 
 export type EndpointParameters = {
   body?: Box<BoxRef>;

package/src/node.export.ts

@@ -1,2 +1 @@
-export { prettify } from "./format.ts";
 export { generateClientFiles } from "./generate-client-files.ts";

package/src/pretty.export.ts

@@ -0,0 +1 @@
+export { prettify } from "./format.ts";

package/src/ref-resolver.ts

@@ -5,8 +5,10 @@ import { Box } from "./box.ts";
 import { isReferenceObject } from "./is-reference-object.ts";
 import { openApiSchemaToTs } from "./openapi-schema-to-ts.ts";
 import { normalizeString } from "./string-utils.ts";
+import { NameTransformOptions } from "./types.ts";
 import { AnyBoxDef, GenericFactory, type LibSchemaObject } from "./types.ts";
 import { topologicalSort } from "./topological-sort.ts";
+import { sanitizeName } from "./sanitize-name.ts";
 
 const autocorrectRef = (ref: string) => (ref[1] === "/" ? ref : "#/" + ref.slice(1));
 const componentsWithSchemas = ["schemas", "responses", "parameters", "requestBodies", "headers"];
@@ -26,7 +28,11 @@ export type RefInfo = {
   kind: "schemas" | "responses" | "parameters" | "requestBodies" | "headers";
 };
 
-export const createRefResolver = (doc: OpenAPIObject, factory: GenericFactory) => {
+export const createRefResolver = (
+  doc: OpenAPIObject,
+  factory: GenericFactory,
+  nameTransform?: NameTransformOptions,
+) => {
   // both used for debugging purpose
   const nameByRef = new Map<string, string>();
   const refByName = new Map<string, string>();
@@ -48,7 +54,11 @@ export const createRefResolver = (doc: OpenAPIObject, factory: GenericFactory) =
 
     // "#/components/schemas/Something.jsonld" -> "Something.jsonld"
     const name = split[split.length - 1]!;
-    const normalized = normalizeString(name);
+    let normalized = normalizeString(name);
+    if (nameTransform?.transformSchemaName) {
+      normalized = nameTransform.transformSchemaName(normalized);
+    }
+    normalized = sanitizeName(normalized, "schema");
 
     nameByRef.set(correctRef, normalized);
     refByName.set(normalized, correctRef);

package/src/sanitize-name.ts

@@ -0,0 +1,79 @@
+const reservedWords = new Set([
+  // TS keywords and built-ins
+  "import",
+  "package",
+  "namespace",
+  "Record",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "String",
+  "Number",
+  "Boolean",
+  "Object",
+  "Array",
+  "Function",
+  "any",
+  "unknown",
+  "never",
+  "void",
+  "extends",
+  "super",
+  "class",
+  "interface",
+  "type",
+  "enum",
+  "const",
+  "let",
+  "var",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "default",
+  "break",
+  "continue",
+  "return",
+  "try",
+  "catch",
+  "finally",
+  "throw",
+  "new",
+  "delete",
+  "in",
+  "instanceof",
+  "typeof",
+  "void",
+  "with",
+  "yield",
+  "await",
+  "static",
+  "public",
+  "private",
+  "protected",
+  "abstract",
+  "as",
+  "asserts",
+  "from",
+  "get",
+  "set",
+  "module",
+  "require",
+  "keyof",
+  "readonly",
+  "global",
+  "symbol",
+  "bigint",
+]);
+
+export function sanitizeName(name: string, type: "schema" | "endpoint") {
+  let n = name.replace(/[\W/]+/g, "_");
+  if (/^\d/.test(n)) n = "_" + n;
+  if (reservedWords.has(n)) n = (type === "schema" ? "Schema_" : "Endpoint_") + n;
+  return n;
+}

package/src/types.ts

@@ -1,8 +1,9 @@
-import type { ReferenceObject, SchemaObject } from "openapi3-ts/oas31";
+import type { OperationObject, ReferenceObject, SchemaObject } from "openapi3-ts/oas31";
 import type { SchemaObject as SchemaObject3 } from "openapi3-ts/oas30";
 
 import type { RefResolver } from "./ref-resolver.ts";
 import { Box } from "./box.ts";
+import type { Method } from "./map-openapi-endpoints.ts";
 
 export type LibSchemaObject = SchemaObject & SchemaObject3;
 
@@ -94,10 +95,22 @@ export type FactoryCreator = (
   schema: SchemaObject | ReferenceObject,
   ctx: OpenapiSchemaConvertContext,
 ) => GenericFactory;
+
+export type NameTransformOptions = {
+  transformSchemaName?: (name: string) => string;
+  transformEndpointName?: (endpoint: {
+    alias: string;
+    operation: OperationObject;
+    method: Method;
+    path: string;
+  }) => string;
+};
+
 export type OpenapiSchemaConvertContext = {
   factory: FactoryCreator | GenericFactory;
   refs: RefResolver;
   onBox?: (box: Box<AnyBoxDef>) => Box<AnyBoxDef>;
+  nameTransform?: NameTransformOptions;
 };
 
 export type StringOrBox = string | Box<AnyBoxDef>;