typed-openapi 1.5.0 → 2.0.0

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-MCVYB63W.js}

@@ -1,10 +1,14 @@
 import {
+  DEFAULT_ERROR_STATUS_CODES,
+  DEFAULT_SUCCESS_STATUS_CODES,
   allowedRuntimes,
   generateFile,
   generateTanstackQueryFile,
-  mapOpenApiEndpoints,
+  mapOpenApiEndpoints
+} from "./chunk-E6A7N4ND.js";
+import {
   prettify
-} from "./chunk-N6BWPZUB.js";
+} from "./chunk-KAEXXJ7X.js";
 
 // src/generate-client-files.ts
 import SwaggerParser from "@apidevtools/swagger-parser";
@@ -24,19 +28,28 @@ var optionsSchema = type({
   "output?": "string",
   runtime: allowedRuntimes,
   tanstack: "boolean | string",
-  schemasOnly: "boolean"
+  schemasOnly: "boolean",
+  "includeClient?": "boolean | 'true' | 'false'",
+  "successStatusCodes?": "string",
+  "errorStatusCodes?": "string"
 });
 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
-    })
-  );
+  const successStatusCodes = options.successStatusCodes ? options.successStatusCodes.split(",").map((code) => parseInt(code.trim(), 10)) : void 0;
+  const errorStatusCodes = options.errorStatusCodes ? options.errorStatusCodes.split(",").map((code) => parseInt(code.trim(), 10)) : void 0;
+  const includeClient = options.includeClient === "false" ? false : options.includeClient === "true" ? true : options.includeClient;
+  const generatorOptions = {
+    ...ctx,
+    runtime: options.runtime,
+    schemasOnly: options.schemasOnly,
+    nameTransform: options.nameTransform,
+    includeClient: includeClient ?? true,
+    successStatusCodes: successStatusCodes ?? DEFAULT_SUCCESS_STATUS_CODES,
+    errorStatusCodes: errorStatusCodes ?? DEFAULT_ERROR_STATUS_CODES
+  };
+  const content = await prettify(generateFile(generatorOptions));
   const outputPath = join(
     cwd,
     options.output ?? input + `.${options.runtime === "none" ? "client" : options.runtime}.ts`
@@ -46,7 +59,7 @@ async function generateClientFiles(input, options) {
   await writeFile(outputPath, content);
   if (options.tanstack) {
     const tanstackContent = await generateTanstackQueryFile({
-      ...ctx,
+      ...generatorOptions,
       relativeApiClientPath: "./" + basename(outputPath)
     });
     const tanstackOutputPath = join(

package/dist/cli.js

@@ -1,9 +1,10 @@
 import {
   generateClientFiles
-} from "./chunk-RGFFCU3R.js";
+} from "./chunk-MCVYB63W.js";
 import {
   allowedRuntimes
-} from "./chunk-N6BWPZUB.js";
+} from "./chunk-E6A7N4ND.js";
+import "./chunk-KAEXXJ7X.js";
 
 // src/cli.ts
 import { cac } from "cac";
@@ -11,10 +12,13 @@ import { readFileSync } from "fs";
 var { name, version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 var cli = cac(name);
 cli.command("<input>", "Generate").option("-o, --output <path>", "Output path for the api client ts file (defaults to `<input>.<runtime>.ts`)").option(
-  "-r, --runtime <name>",
+  "-r, --runtime <n>",
   `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.toString()}`,
   { default: "none" }
-).option("--schemas-only", "Only generate schemas, skipping client generation (defaults to false)", { default: false }).option(
+).option("--schemas-only", "Only generate schemas, skipping client generation (defaults to false)", { default: false }).option("--include-client", "Include API client types and implementation (defaults to true)", { default: true }).option(
+  "--success-status-codes <codes>",
+  "Comma-separated list of success status codes (defaults to 2xx and 3xx ranges)"
+).option("--error-status-codes <codes>", "Comma-separated list of error status codes (defaults to 4xx and 5xx ranges)").option(
   "--tanstack [name]",
   "Generate tanstack client, defaults to false, can optionally specify a name for the generated file"
 ).action(async (input, _options) => {

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-DsI2d-HE.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-DsI2d-HE.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,13 @@ 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;
+    successStatusCodes?: readonly number[];
+    errorStatusCodes?: readonly number[];
+    includeClient?: boolean;
 };
 declare const allowedRuntimes: arktype_internal_methods_string_ts.StringType<"none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod", {}>;
 type OutputRuntime = typeof allowedRuntimes.infer;
@@ -253,7 +33,9 @@ declare const runtimeValidationGenerator: {
 declare const generateFile: (options: GeneratorOptions$1) => string;
 
 type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints>;
-type GeneratorContext = Required<GeneratorOptions>;
+type GeneratorContext = Required<GeneratorOptions> & {
+    errorStatusCodes?: readonly number[];
+};
 declare const generateTanstackQueryFile: (ctx: GeneratorContext & {
     relativeApiClientPath: string;
 }) => Promise<string>;
@@ -276,4 +58,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-E6A7N4ND.js";
+import "./chunk-KAEXXJ7X.js";
 export {
   createBoxFactory,
   createFactory,

package/dist/node.export.d.ts

@@ -1,14 +1,20 @@
-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-DsI2d-HE.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";
     tanstack: string | boolean;
     schemasOnly: boolean;
     output?: string;
+    includeClient?: boolean | "false" | "true";
+    successStatusCodes?: string;
+    errorStatusCodes?: 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-MCVYB63W.js";
+import "./chunk-E6A7N4ND.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
+};