typed-openapi 0.10.0 → 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2025 Alexandre Stahmer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/{chunk-WT2PCM73.js → chunk-STLPDNLW.js}

@@ -15,8 +15,7 @@ function normalizeString(text) {
 }
 var onlyWordRegex = /^\w+$/;
 var wrapWithQuotesIfNeeded = (str) => {
-  if (str[0] === '"' && str[str.length - 1] === '"')
-    return str;
+  if (str[0] === '"' && str[str.length - 1] === '"') return str;
   if (onlyWordRegex.test(str)) {
     return str;
   }
@@ -52,7 +51,7 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
       return t.union(schema.type.map((prop) => openApiSchemaToTs({ schema: { ...schema, type: prop }, ctx, meta })));
     }
     if (schema.type === "null") {
-      return t.reference("null");
+      return t.literal("null");
     }
     if (schema.oneOf) {
       if (schema.oneOf.length === 1) {
@@ -89,14 +88,10 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
         }
         return t.union(schema.enum.map((value) => t.literal(value === null ? "null" : value)));
       }
-      if (schemaType === "string")
-        return t.string();
-      if (schemaType === "boolean")
-        return t.boolean();
-      if (schemaType === "number" || schemaType === "integer")
-        return t.number();
-      if (schemaType === "null")
-        return t.reference("null");
+      if (schemaType === "string") return t.string();
+      if (schemaType === "boolean") return t.boolean();
+      if (schemaType === "number" || schemaType === "integer") return t.number();
+      if (schemaType === "null") return t.literal("null");
     }
     if (schemaType === "array") {
       if (schema.items) {
@@ -110,7 +105,11 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
     }
     if (schemaType === "object" || schema.properties || schema.additionalProperties) {
       if (!schema.properties) {
-        return t.unknown();
+        if (schema.additionalProperties && !isReferenceObject(schema.additionalProperties) && typeof schema.additionalProperties !== "boolean" && schema.additionalProperties.type) {
+          const valueSchema = openApiSchemaToTs({ schema: schema.additionalProperties, ctx, meta });
+          return t.literal(`Record<string, ${valueSchema.value}>`);
+        }
+        return t.literal("Record<string, unknown>");
       }
       let additionalProperties;
       if (schema.additionalProperties) {
@@ -142,14 +141,13 @@ var openApiSchemaToTs = ({ schema, meta: _inheritedMeta, ctx }) => {
       const objectType = additionalProperties ? t.intersection([t.object(props), additionalProperties]) : t.object(props);
       return isPartial ? t.reference("Partial", [objectType]) : objectType;
     }
-    if (!schemaType)
-      return t.unknown();
+    if (!schemaType) return t.unknown();
     throw new Error(`Unsupported schema type: ${schemaType}`);
   };
   let output = getTs();
   if (!isReferenceObject(schema)) {
     if (schema.nullable) {
-      output = t.union([output, t.reference("null")]);
+      output = t.union([output, t.literal("null")]);
     }
   }
   return output;
@@ -254,26 +252,6 @@ var createBoxFactory = (schema, ctx) => {
 
 // src/generator.ts
 import { capitalize as capitalize2, groupBy } from "pastable/server";
-
-// 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 });
-
-// src/generator.ts
 import * as Codegen from "@sinclair/typebox-codegen";
 import { match } from "ts-pattern";
 import { type } from "arktype";
@@ -328,7 +306,7 @@ var generateFile = (options) => {
   ${transform(schemaList + endpointSchemaList)}
   ${apiClient}
   `;
-  return prettify(file);
+  return file;
 };
 var generateSchemaList = ({ refs, runtime }) => {
   let file = `
@@ -336,10 +314,8 @@ var generateSchemaList = ({ refs, runtime }) => {
     // <Schemas>
   `;
   refs.getOrderedSchemas().forEach(([schema, infos]) => {
-    if (!infos?.name)
-      return;
-    if (infos.kind !== "schemas")
-      return;
+    if (!infos?.name) return;
+    if (infos.kind !== "schemas") return;
     file += `export type ${infos.normalized} = ${schema.value}
 `;
   });
@@ -349,8 +325,7 @@ var generateSchemaList = ({ refs, runtime }) => {
   `;
 };
 var parameterObjectToString = (parameters) => {
-  if (parameters instanceof Box)
-    return parameters.value;
+  if (parameters instanceof Box) return parameters.value;
   let str = "{";
   for (const [key, box] of Object.entries(parameters)) {
     str += `${wrapWithQuotesIfNeeded(key)}: ${box.value},
@@ -384,7 +359,7 @@ var generateEndpointSchemaList = (ctx) => {
     )},` : ""}
           }` : "parameters: never,"}
       response: ${ctx.runtime === "none" ? endpoint.response.recompute((box) => {
-      if (Box.isReference(box) && !box.params.generics) {
+      if (Box.isReference(box) && !box.params.generics && box.value !== "null") {
         box.value = `Schemas.${box.value}`;
       }
       return box;
@@ -525,8 +500,7 @@ import { get } from "pastable/server";
 function topologicalSort(graph) {
   const sorted = [], visited = {};
   function visit(name, ancestors) {
-    if (!Array.isArray(ancestors))
-      ancestors = [];
+    if (!Array.isArray(ancestors)) ancestors = [];
     ancestors.push(name);
     visited[name] = true;
     const deps = graph.get(name);
@@ -535,13 +509,11 @@ function topologicalSort(graph) {
         if (ancestors.includes(dep)) {
           return;
         }
-        if (visited[dep])
-          return;
+        if (visited[dep]) return;
         visit(dep, ancestors.slice(0));
       });
     }
-    if (!sorted.includes(name))
-      sorted.push(name);
+    if (!sorted.includes(name)) sorted.push(name);
   }
   graph.forEach((_, name) => visit(name, []));
   return sorted;
@@ -620,8 +592,7 @@ var createRefResolver = (doc, factory2) => {
 };
 var setSchemaDependencies = (schema, deps) => {
   const visit = (schema2) => {
-    if (!schema2)
-      return;
+    if (!schema2) return;
     if (isReferenceObject(schema2)) {
       deps.add(schema2.$ref);
       return;
@@ -645,8 +616,7 @@ var setSchemaDependencies = (schema, deps) => {
       return;
     }
     if (schema2.type === "array") {
-      if (!schema2.items)
-        return;
+      if (!schema2.items) return;
       return void visit(schema2.items);
     }
     if (schema2.type === "object" || schema2.properties || schema2.additionalProperties) {
@@ -675,8 +645,7 @@ var getTransitiveDependencies = (directDependencies) => {
       if (deps2 && ref !== depRef) {
         deps2.forEach((transitive) => {
           const key = ref + "__" + transitive;
-          if (visitedsDeepRefs.has(key))
-            return;
+          if (visitedsDeepRefs.has(key)) return;
           visitedsDeepRefs.add(key);
           visit(transitive);
         });
@@ -722,8 +691,7 @@ var mapOpenApiEndpoints = (doc) => {
   Object.entries(doc.paths ?? {}).forEach(([path, pathItemObj]) => {
     const pathItem = pick(pathItemObj, ["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
     Object.entries(pathItem).forEach(([method, operation]) => {
-      if (operation.deprecated)
-        return;
+      if (operation.deprecated) return;
       const endpoint = {
         operation,
         method,
@@ -741,8 +709,7 @@ var mapOpenApiEndpoints = (doc) => {
         (acc, paramOrRef) => {
           const param = refs.unwrap(paramOrRef);
           const schema = openApiSchemaToTs({ schema: refs.unwrap(param.schema ?? {}), ctx });
-          if (param.required)
-            endpoint.meta.areParametersRequired = true;
+          if (param.required) endpoint.meta.areParametersRequired = true;
           endpoint.meta.hasParameters = true;
           if (param.in === "query") {
             lists.query.push(param);
@@ -798,13 +765,13 @@ var mapOpenApiEndpoints = (doc) => {
         endpoint.parameters = Object.keys(params).length ? params : void 0;
       }
       let responseObject;
-      Object.entries(operation.responses).map(([status, responseOrRef]) => {
+      Object.entries(operation.responses ?? {}).map(([status, responseOrRef]) => {
         const statusCode = Number(status);
         if (statusCode >= 200 && statusCode < 300) {
           responseObject = refs.unwrap(responseOrRef);
         }
       });
-      if (!responseObject && operation.responses.default) {
+      if (!responseObject && operation.responses?.default) {
         responseObject = refs.unwrap(operation.responses.default);
       }
       const content = responseObject?.content;
@@ -832,6 +799,121 @@ var isAllowedParamMediaTypes = (mediaType) => mediaType.includes("application/")
 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 });
+
+// src/tanstack-query.generator.ts
+import { capitalize as capitalize4 } from "pastable/server";
+var generateTanstackQueryFile = async (ctx) => {
+  const endpointMethods = new Set(ctx.endpointList.map((endpoint) => endpoint.method.toLowerCase()));
+  const file = `
+  import { queryOptions, QueryClient } from "@tanstack/react-query"
+  import type { EndpointByMethod, ApiClient } from "${ctx.relativeApiClientPath}"
+
+  type EndpointQueryKey<TOptions extends EndpointParameters> = [
+      TOptions & {
+          _id: string;
+          _infinite?: boolean;
+      }
+  ];
+
+  const createQueryKey = <TOptions extends EndpointParameters>(id: string, options?: TOptions, infinite?: boolean): [
+      EndpointQueryKey<TOptions>[0]
+  ] => {
+      const params: EndpointQueryKey<TOptions>[0] = { _id: id, } as EndpointQueryKey<TOptions>[0];
+      if (infinite) {
+          params._infinite = infinite;
+      }
+      if (options?.body) {
+          params.body = options.body;
+      }
+      if (options?.header) {
+          params.header = options.header;
+      }
+      if (options?.path) {
+          params.path = options.path;
+      }
+      if (options?.query) {
+          params.query = options.query;
+      }
+      return [
+          params
+      ];
+  };
+
+  // <EndpointByMethod.Shorthands>
+  ${Array.from(endpointMethods).map((method) => `export type ${capitalize4(method)}Endpoints = EndpointByMethod["${method}"];`).join("\n")}
+  // </EndpointByMethod.Shorthands>
+
+  // <ApiClientTypes>
+  export type EndpointParameters = {
+      body?: unknown;
+      query?: Record<string, unknown>;
+      header?: Record<string, unknown>;
+      path?: Record<string, unknown>;
+  };
+
+  type RequiredKeys<T> = {
+      [P in keyof T]-?: undefined extends T[P] ? never : P;
+  }[keyof T];
+
+  type MaybeOptionalArg<T> = RequiredKeys<T> extends never ? [config?: T] : [config: T];
+
+  // </ApiClientTypes>
+
+  // <ApiClient>
+  export class TanstackQueryApiClient {
+      constructor(public client: ApiClient) { }
+
+      ${Array.from(endpointMethods).map((method) => `
+        // <ApiClient.${method}>
+        ${method}<Path extends keyof ${capitalize4(method)}Endpoints, TEndpoint extends ${capitalize4(method)}Endpoints[Path]>(
+            path: Path,
+            ...params: MaybeOptionalArg<TEndpoint["parameters"]>
+        ) {
+            const queryKey = createQueryKey(path, params[0]);
+            const query = {
+                endpoint: {} as TEndpoint,
+                res: {} as TEndpoint["response"],
+                queryKey,
+                options: queryOptions({
+                    queryFn: async ({ queryKey, signal, }) => {
+                        const res = await this.client.${method}(path, {
+                            ...params,
+                            ...queryKey[0],
+                            signal,
+                            throwOnError: true
+                        });
+                        return res as TEndpoint["response"];
+                    },
+                    queryKey: queryKey
+                }),
+            };
+
+            return query
+        }
+        // </ApiClient.get>
+        `).join("\n")}
+  }
+`;
+  return prettify(file);
+};
+
 export {
   unwrap,
   createFactory,
@@ -841,5 +923,7 @@ export {
   generateFile,
   createRefResolver,
   tsFactory,
-  mapOpenApiEndpoints
+  mapOpenApiEndpoints,
+  prettify,
+  generateTanstackQueryFile
 };

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 
-export { }
+export {  }

package/dist/cli.js

@@ -1,41 +1,48 @@
 import {
   allowedRuntimes,
   generateFile,
-  mapOpenApiEndpoints
-} from "./chunk-WT2PCM73.js";
+  generateTanstackQueryFile,
+  mapOpenApiEndpoints,
+  prettify
+} from "./chunk-STLPDNLW.js";
 
 // src/cli.ts
 import SwaggerParser from "@apidevtools/swagger-parser";
 import { cac } from "cac";
-import { join } from "pathe";
+import { basename, join } from "pathe";
 import { type } from "arktype";
 import { writeFile } from "fs/promises";
-
-// package.json
-var name = "typed-openapi";
-var version = "0.10.0";
-
-// src/cli.ts
+import { readFileSync } from "fs";
+var { name, version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
 var cwd = process.cwd();
 var cli = cac(name);
 var now = /* @__PURE__ */ new Date();
-var optionsSchema = type({ "output?": "string", runtime: allowedRuntimes });
+var optionsSchema = type({ "output?": "string", runtime: allowedRuntimes, tanstack: "boolean | string" });
 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>",
-  `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.definition}`,
+  `Runtime to use for validation; defaults to \`none\`; available: ${allowedRuntimes.toString()}`,
   { default: "none" }
-).action(async (input, _options) => {
+).option("--tanstack [name]", "Generate tanstack client, defaults to false, can optionally specify a name for the generated file").action(async (input, _options) => {
   const options = optionsSchema.assert(_options);
   const openApiDoc = await SwaggerParser.bundle(input);
   const ctx = mapOpenApiEndpoints(openApiDoc);
   console.log(`Found ${ctx.endpointList.length} endpoints`);
-  const content = generateFile({ ...ctx, runtime: options.runtime });
-  const output = join(
+  const content = await prettify(generateFile({ ...ctx, runtime: options.runtime }));
+  const outputPath = join(
     cwd,
     options.output ?? input + `.${options.runtime === "none" ? "client" : options.runtime}.ts`
   );
-  console.log("Generating...", output);
-  await writeFile(output, content);
+  console.log("Generating client...", outputPath);
+  await writeFile(outputPath, content);
+  if (options.tanstack) {
+    const tanstackContent = await generateTanstackQueryFile({
+      ...ctx,
+      relativeApiClientPath: "./" + basename(outputPath)
+    });
+    const tanstackOutputPath = join(cwd, typeof options.tanstack === "string" ? options.tanstack : `tanstack.client.ts`);
+    console.log("Generating tanstack client...", tanstackOutputPath);
+    await writeFile(tanstackOutputPath, tanstackContent);
+  }
   console.log(`Done in ${(/* @__PURE__ */ new Date()).getTime() - now.getTime()}ms !`);
 });
 cli.help();

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
-import { OpenAPIObject, SchemaObject, ReferenceObject, OperationObject } from 'openapi3-ts/oas31';
-import * as arktype from 'arktype';
+import { OpenAPIObject, ReferenceObject, SchemaObject, OperationObject } from 'openapi3-ts/oas31';
+import { SchemaObject as SchemaObject$1 } from 'openapi3-ts/oas30';
+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> {
@@ -44,8 +45,8 @@ type RefInfo = {
     kind: "schemas" | "responses" | "parameters" | "requestBodies" | "headers";
 };
 declare const createRefResolver: (doc: OpenAPIObject, factory: GenericFactory) => {
-    get: <T = SchemaObject>(ref: string) => NonNullable<T>;
-    unwrap: <T_1 extends {} | ReferenceObject>(component: T_1) => Exclude<T_1, ReferenceObject>;
+    get: <T = LibSchemaObject>(ref: string) => NonNullable<T>;
+    unwrap: <T extends ReferenceObject | {}>(component: T) => Exclude<T, ReferenceObject>;
     getInfosByRef: (ref: string) => RefInfo;
     infos: Map<string, RefInfo>;
     /**
@@ -59,6 +60,7 @@ declare const createRefResolver: (doc: OpenAPIObject, factory: GenericFactory) =
 interface RefResolver extends ReturnType<typeof createRefResolver> {
 }
 
+type LibSchemaObject = SchemaObject & SchemaObject$1;
 type BoxDefinition = {
     type: string;
     params: unknown;
@@ -66,7 +68,7 @@ type BoxDefinition = {
 };
 type BoxParams = string | BoxDefinition;
 type WithSchema = {
-    schema: SchemaObject | ReferenceObject | undefined;
+    schema: LibSchemaObject | ReferenceObject | undefined;
     ctx: OpenapiSchemaConvertContext;
 };
 type BoxUnion = WithSchema & {
@@ -171,17 +173,17 @@ type GenericFactory = {
 };
 
 declare const unwrap: (param: StringOrBox) => string;
-declare const createFactory: <T extends GenericFactory | FactoryCreator>(f: T) => T;
+declare const createFactory: <T extends OpenapiSchemaConvertContext["factory"]>(f: T) => T;
 /**
  * Create a box-factory using your schema provider and automatically add the input schema to each box.
  */
-declare const createBoxFactory: (schema: SchemaObject | ReferenceObject, ctx: OpenapiSchemaConvertContext) => BoxFactory;
+declare const createBoxFactory: (schema: LibSchemaObject | ReferenceObject, ctx: OpenapiSchemaConvertContext) => BoxFactory;
 
 declare const mapOpenApiEndpoints: (doc: OpenAPIObject) => {
     doc: OpenAPIObject;
     refs: {
-        get: <T = openapi3_ts_oas31.SchemaObject>(ref: string) => NonNullable<T>;
-        unwrap: <T_1 extends {} | openapi3_ts_oas31.ReferenceObject>(component: T_1) => Exclude<T_1, openapi3_ts_oas31.ReferenceObject>;
+        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][];
@@ -232,10 +234,10 @@ type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
     response: TConfig["response"];
 };
 
-type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints> & {
+type GeneratorOptions$1 = ReturnType<typeof mapOpenApiEndpoints> & {
     runtime?: "none" | keyof typeof runtimeValidationGenerator;
 };
-declare const allowedRuntimes: arktype.Type<"zod" | "arktype" | "typebox" | "valibot" | "yup" | "io-ts" | "none">;
+declare const allowedRuntimes: arktype_internal_methods_string_ts.StringType<"none" | "arktype" | "io-ts" | "typebox" | "valibot" | "yup" | "zod", {}>;
 type OutputRuntime = typeof allowedRuntimes.infer;
 declare const runtimeValidationGenerator: {
     arktype: typeof Codegen.ModelToArkType.Generate;
@@ -245,7 +247,13 @@ declare const runtimeValidationGenerator: {
     yup: typeof Codegen.ModelToYup.Generate;
     zod: typeof Codegen.ModelToZod.Generate;
 };
-declare const generateFile: (options: GeneratorOptions) => string;
+declare const generateFile: (options: GeneratorOptions$1) => string;
+
+type GeneratorOptions = ReturnType<typeof mapOpenApiEndpoints>;
+type GeneratorContext = Required<GeneratorOptions>;
+declare const generateTanstackQueryFile: (ctx: GeneratorContext & {
+    relativeApiClientPath: string;
+}) => Promise<string>;
 
 declare const openApiSchemaToTs: ({ schema, meta: _inheritedMeta, ctx }: OpenapiSchemaConvertArgs) => Box<AnyBoxDef>;
 
@@ -265,4 +273,4 @@ declare const tsFactory: {
     object: (props: Record<string, StringOrBox>) => string;
 };
 
-export { AnyBox, AnyBoxDef, BoxArray, BoxDefinition, BoxFactory, BoxIntersection, BoxKeyword, BoxLiteral, BoxObject, BoxOptional, BoxParams, BoxRef, BoxUnion, Endpoint, EndpointParameters, FactoryCreator, GenericFactory, OpenapiSchemaConvertArgs, OpenapiSchemaConvertContext, OutputRuntime, RefInfo, RefResolver, StringOrBox, WithSchema, createBoxFactory, createFactory, createRefResolver, generateFile, mapOpenApiEndpoints, openApiSchemaToTs, tsFactory, unwrap };
+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 };

package/dist/index.js

@@ -3,16 +3,18 @@ import {
   createFactory,
   createRefResolver,
   generateFile,
+  generateTanstackQueryFile,
   mapOpenApiEndpoints,
   openApiSchemaToTs,
   tsFactory,
   unwrap
-} from "./chunk-WT2PCM73.js";
+} from "./chunk-STLPDNLW.js";
 export {
   createBoxFactory,
   createFactory,
   createRefResolver,
   generateFile,
+  generateTanstackQueryFile,
   mapOpenApiEndpoints,
   openApiSchemaToTs,
   tsFactory,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typed-openapi",
   "type": "module",
-  "version": "0.10.0",
+  "version": "1.0.0",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "bin": {
@@ -13,24 +13,23 @@
     "directory": "packages/typed-openapi"
   },
   "dependencies": {
-    "@apidevtools/swagger-parser": "^10.1.0",
-    "@changesets/cli": "^2.26.2",
-    "@sinclair/typebox-codegen": "^0.10.5",
-    "arktype": "1.0.18-alpha",
+    "@apidevtools/swagger-parser": "^10.1.1",
+    "@sinclair/typebox-codegen": "^0.11.1",
+    "arktype": "2.1.20",
     "cac": "^6.7.14",
-    "openapi3-ts": "^4.1.2",
+    "openapi3-ts": "^4.4.0",
     "pastable": "^2.2.1",
-    "pathe": "^1.1.1",
-    "prettier": "2.8.4",
-    "ts-pattern": "^5.0.4"
+    "pathe": "^2.0.3",
+    "prettier": "3.5.3",
+    "ts-pattern": "^5.7.0"
   },
   "devDependencies": {
-    "@types/node": "^20.4.5",
-    "@types/prettier": "2.7.3",
-    "tsup": "^7.1.0",
-    "typescript": "^5.1.6",
-    "vite-node": "^0.33.0",
-    "vitest": "^0.33.0"
+    "@changesets/cli": "^2.29.4",
+    "@types/node": "^22.15.17",
+    "@types/prettier": "3.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.3"
   },
   "files": [
     "src",
@@ -60,6 +59,6 @@
     "dev": "tsup --watch",
     "build": "tsup",
     "test": "vitest",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc -b ./tsconfig.build.json"
   }
 }

package/src/asserts.ts

@@ -1,6 +1,6 @@
-import type { SchemaObject } from "openapi3-ts/oas31";
+import type { LibSchemaObject } from "./types.ts";
 
-export type SingleType = Exclude<SchemaObject["type"], any[] | undefined>;
+export type SingleType = Exclude<LibSchemaObject["type"], any[] | undefined>;
 export const isPrimitiveType = (type: unknown): type is PrimitiveType => primitiveTypeList.includes(type as any);
 
 const primitiveTypeList = ["string", "number", "integer", "boolean", "null"] as const;

package/src/box-factory.ts

@@ -1,6 +1,6 @@
-import type { ReferenceObject, SchemaObject } from "openapi3-ts/oas31";
-import { Box } from "./box";
-import { AnyBoxDef, BoxFactory, OpenapiSchemaConvertContext, StringOrBox } from "./types";
+import type { ReferenceObject } from "openapi3-ts/oas31";
+import { Box } from "./box.ts";
+import { AnyBoxDef, BoxFactory, OpenapiSchemaConvertContext, StringOrBox, type LibSchemaObject } from "./types.ts";
 
 export const unwrap = (param: StringOrBox) => (typeof param === "string" ? param : param.value);
 export const createFactory = <T extends OpenapiSchemaConvertContext["factory"]>(f: T) => f;
@@ -8,7 +8,7 @@ export const createFactory = <T extends OpenapiSchemaConvertContext["factory"]>(
 /**
  * Create a box-factory using your schema provider and automatically add the input schema to each box.
  */
-export const createBoxFactory = (schema: SchemaObject | ReferenceObject, ctx: OpenapiSchemaConvertContext) => {
+export const createBoxFactory = (schema: LibSchemaObject | ReferenceObject, ctx: OpenapiSchemaConvertContext) => {
   const f = typeof ctx.factory === "function" ? ctx.factory(schema, ctx) : ctx.factory;
   const callback = <T extends AnyBoxDef>(box: Box<T>) => {
     if (f.callback) {

package/src/box.ts

@@ -1,5 +1,4 @@
-import { SchemaObject } from "openapi3-ts/oas31";
-import { openApiSchemaToTs } from "./openapi-schema-to-ts";
+import { openApiSchemaToTs } from "./openapi-schema-to-ts.ts";
 import {
   AnyBoxDef,
   BoxArray,
@@ -11,7 +10,8 @@ import {
   BoxRef,
   BoxUnion,
   OpenapiSchemaConvertContext,
-} from "./types";
+  type LibSchemaObject,
+} from "./types.ts";
 
 // TODO rename SchemaBox
 export class Box<T extends AnyBoxDef = AnyBoxDef> {
@@ -39,7 +39,7 @@ export class Box<T extends AnyBoxDef = AnyBoxDef> {
   }
 
   recompute(callback: OpenapiSchemaConvertContext["onBox"]) {
-    return openApiSchemaToTs({ schema: this.schema as SchemaObject, ctx: { ...this.ctx, onBox: callback! } });
+    return openApiSchemaToTs({ schema: this.schema as LibSchemaObject, ctx: { ...this.ctx, onBox: callback! } });
   }
 
   static fromJSON(json: string) {