@depup/openapi-typescript 7.13.0-depup.0

package/dist/transform/webhooks-object.mjs

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import { tsModifiers, tsPropertyIndex } from '../lib/ts.mjs';
+import { getEntries, createRef } from '../lib/utils.mjs';
+import transformPathItemObject from './path-item-object.mjs';
+
+function transformWebhooksObject(webhooksObject, options) {
+  const type = [];
+  for (const [name, pathItemObject] of getEntries(webhooksObject, options)) {
+    type.push(
+      ts.factory.createPropertySignature(
+        /* modifiers     */
+        tsModifiers({
+          readonly: options.immutable
+        }),
+        /* name          */
+        tsPropertyIndex(name),
+        /* questionToken */
+        void 0,
+        /* type          */
+        transformPathItemObject(pathItemObject, {
+          path: createRef(["webhooks", name]),
+          ctx: options
+        })
+      )
+    );
+  }
+  return ts.factory.createTypeLiteralNode(type);
+}
+
+export { transformWebhooksObject as default };
+//# sourceMappingURL=webhooks-object.mjs.map

package/dist/transform/webhooks-object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks-object.mjs","sources":["../../src/transform/webhooks-object.ts"],"sourcesContent":["import ts from \"typescript\";\nimport { tsModifiers, tsPropertyIndex } from \"../lib/ts.js\";\nimport { createRef, getEntries } from \"../lib/utils.js\";\nimport type { GlobalContext, WebhooksObject } from \"../types.js\";\nimport transformPathItemObject from \"./path-item-object.js\";\n\nexport default function transformWebhooksObject(webhooksObject: WebhooksObject, options: GlobalContext): ts.TypeNode {\n  const type: ts.TypeElement[] = [];\n\n  for (const [name, pathItemObject] of getEntries(webhooksObject, options)) {\n    type.push(\n      ts.factory.createPropertySignature(\n        /* modifiers     */ tsModifiers({\n          readonly: options.immutable,\n        }),\n        /* name          */ tsPropertyIndex(name),\n        /* questionToken */ undefined,\n        /* type          */ transformPathItemObject(pathItemObject, {\n          path: createRef([\"webhooks\", name]),\n          ctx: options,\n        }),\n      ),\n    );\n  }\n\n  return ts.factory.createTypeLiteralNode(type);\n}\n"],"names":[],"mappings":";;;;;AAMA,SAAwB,uBAAA,CAAwB,gBAAgC,OAAA,EAAqC;AACnH,EAAA,MAAM,OAAyB,EAAC;AAEhC,EAAA,KAAA,MAAW,CAAC,IAAA,EAAM,cAAc,KAAK,UAAA,CAAW,cAAA,EAAgB,OAAO,CAAA,EAAG;AACxE,IAAA,IAAA,CAAK,IAAA;AAAA,MACH,GAAG,OAAA,CAAQ,uBAAA;AAAA;AAAA,QACW,WAAA,CAAY;AAAA,UAC9B,UAAU,OAAA,CAAQ;AAAA,SACnB,CAAA;AAAA;AAAA,QACmB,gBAAgB,IAAI,CAAA;AAAA;AAAA,QACpB,MAAA;AAAA;AAAA,QACA,wBAAwB,cAAA,EAAgB;AAAA,UAC1D,IAAA,EAAM,SAAA,CAAU,CAAC,UAAA,EAAY,IAAI,CAAC,CAAA;AAAA,UAClC,GAAA,EAAK;AAAA,SACN;AAAA;AACH,KACF;AAAA,EACF;AAEA,EAAA,OAAO,EAAA,CAAG,OAAA,CAAQ,qBAAA,CAAsB,IAAI,CAAA;AAC9C;;;;"}

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@depup/openapi-typescript",
+  "description": "Convert OpenAPI 3.0 & 3.1 schemas to TypeScript (with updated dependencies)",
+  "version": "7.13.0-depup.0",
+  "author": {
+    "name": "Drew Powers",
+    "email": "drew@pow.rs"
+  },
+  "license": "MIT",
+  "bin": {
+    "openapi-typescript": "bin/cli.js"
+  },
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    },
+    "./*.js": "./*.mjs",
+    "./*": "./*"
+  },
+  "homepage": "https://openapi-ts.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openapi-ts/openapi-typescript",
+    "directory": "packages/openapi-typescript"
+  },
+  "keywords": [
+    "openapi-typescript",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
+    "swagger",
+    "typescript",
+    "ts",
+    "dts",
+    "openapi",
+    "codegen",
+    "generation",
+    "openapi 3",
+    "node"
+  ],
+  "bugs": {
+    "url": "https://github.com/openapi-ts/openapi-typescript/issues"
+  },
+  "peerDependencies": {
+    "typescript": "^5.x"
+  },
+  "dependencies": {
+    "@redocly/openapi-core": "^2.24.1",
+    "ansi-colors": "^4.1.3",
+    "change-case": "^5.4.4",
+    "parse-json": "^8.3.0",
+    "supports-color": "^10.2.2",
+    "yargs-parser": "^22.0.0"
+  },
+  "devDependencies": {
+    "@types/degit": "2.8.6",
+    "@types/js-yaml": "4.0.9",
+    "degit": "2.8.4",
+    "execa": "^9.6.1",
+    "strip-ansi": "7.1.2",
+    "typescript": "^5.9.3",
+    "vite-node": "5.3.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "download:schemas": "vite-node ./scripts/download-schemas.ts",
+    "format": "biome format . --write",
+    "lint": "pnpm run lint:js && pnpm run lint:ts",
+    "lint:js": "biome check .",
+    "lint:ts": "tsc --noEmit",
+    "test": "pnpm run test:js && pnpm run test:examples && pnpm run test:exports",
+    "test:js": "vitest run",
+    "test:exports": "pnpm run build && attw --pack .",
+    "test:examples": "tsc -p tsconfig.examples.json --noEmit",
+    "update:examples": "pnpm run build && pnpm run download:schemas && vite-node ./scripts/update-examples.ts",
+    "version": "pnpm run build"
+  },
+  "depup": {
+    "changes": {
+      "@redocly/openapi-core": {
+        "from": "^1.34.6",
+        "to": "^2.24.1"
+      },
+      "yargs-parser": {
+        "from": "^21.1.1",
+        "to": "^22.0.0"
+      }
+    },
+    "depsUpdated": 2,
+    "originalPackage": "openapi-typescript",
+    "originalVersion": "7.13.0",
+    "processedAt": "2026-03-22T00:40:17.761Z",
+    "smokeTest": "failed"
+  }
+}

package/src/index.ts

@@ -0,0 +1,108 @@
+import { performance } from "node:perf_hooks";
+import type { Readable } from "node:stream";
+import { createConfig } from "@redocly/openapi-core";
+import type ts from "typescript";
+import { validateAndBundle } from "./lib/redoc.js";
+import { debug, resolveRef, scanDiscriminators } from "./lib/utils.js";
+import transformSchema from "./transform/index.js";
+import type { GlobalContext, OpenAPI3, OpenAPITSOptions } from "./types.js";
+
+export * from "./lib/ts.js";
+export * from "./lib/utils.js";
+export { default as transformComponentsObject } from "./transform/components-object.js";
+export { default as transformHeaderObject } from "./transform/header-object.js";
+export { default as transformSchema } from "./transform/index.js";
+export { default as transformMediaTypeObject } from "./transform/media-type-object.js";
+export * from "./transform/operation-object.js";
+export { default as transformOperationObject } from "./transform/operation-object.js";
+export { default as transformParameterObject } from "./transform/parameter-object.js";
+export * from "./transform/path-item-object.js";
+export { default as transformPathItemObject } from "./transform/path-item-object.js";
+export { default as transformPathsObject } from "./transform/paths-object.js";
+export { default as transformRequestBodyObject } from "./transform/request-body-object.js";
+export { default as transformResponseObject } from "./transform/response-object.js";
+export { default as transformResponsesObject } from "./transform/responses-object.js";
+export * from "./transform/schema-object.js";
+export { default as transformSchemaObject } from "./transform/schema-object.js";
+export * from "./types.js";
+
+export const COMMENT_HEADER = `/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+`;
+
+/**
+ * Convert an OpenAPI schema to TypesScript AST
+ * @param {string|URL|object|Readable} source OpenAPI schema source:
+ *   - YAML: string
+ *   - JSON: parsed object
+ *   - URL: URL to a YAML or JSON file (local or remote)
+ *   - Readable: Readable stream of YAML or JSON
+ */
+export default async function openapiTS(
+  source: string | URL | OpenAPI3 | Buffer | Readable,
+  options: OpenAPITSOptions = {} as Partial<OpenAPITSOptions>,
+): Promise<ts.Node[]> {
+  if (!source) {
+    throw new Error("Empty schema. Please specify a URL, file path, or Redocly Config");
+  }
+
+  const redoc =
+    options.redocly ??
+    (await createConfig(
+      {
+        rules: {
+          "operation-operationId-unique": { severity: "error" }, // throw error on duplicate operationIDs
+        },
+      },
+      { extends: ["minimal"] },
+    ));
+
+  const schema = await validateAndBundle(source, {
+    redoc,
+    cwd: options.cwd instanceof URL ? options.cwd : new URL(`file://${options.cwd ?? process.cwd()}/`),
+    silent: options.silent ?? false,
+  });
+
+  const ctx: GlobalContext = {
+    additionalProperties: options.additionalProperties ?? false,
+    alphabetize: options.alphabetize ?? false,
+    arrayLength: options.arrayLength ?? false,
+    defaultNonNullable: options.defaultNonNullable ?? true,
+    discriminators: scanDiscriminators(schema, options),
+    emptyObjectsUnknown: options.emptyObjectsUnknown ?? false,
+    enum: options.enum ?? false,
+    enumValues: options.enumValues ?? false,
+    conditionalEnums: options.conditionalEnums ?? false,
+    dedupeEnums: options.dedupeEnums ?? false,
+    excludeDeprecated: options.excludeDeprecated ?? false,
+    exportType: options.exportType ?? false,
+    immutable: options.immutable ?? false,
+    rootTypes: options.rootTypes ?? false,
+    rootTypesNoSchemaPrefix: options.rootTypesNoSchemaPrefix ?? false,
+    rootTypesKeepCasing: options.rootTypesKeepCasing ?? false,
+    injectFooter: [],
+    pathParamsAsTypes: options.pathParamsAsTypes ?? false,
+    postTransform: typeof options.postTransform === "function" ? options.postTransform : undefined,
+    propertiesRequiredByDefault: options.propertiesRequiredByDefault ?? false,
+    redoc,
+    silent: options.silent ?? false,
+    inject: options.inject ?? undefined,
+    transform: typeof options.transform === "function" ? options.transform : undefined,
+    transformProperty: typeof options.transformProperty === "function" ? options.transformProperty : undefined,
+    makePathsEnum: options.makePathsEnum ?? false,
+    generatePathParams: options.generatePathParams ?? false,
+    readWriteMarkers: options.readWriteMarkers ?? false,
+    resolve($ref) {
+      return resolveRef(schema, $ref, { silent: options.silent ?? false });
+    },
+  };
+
+  const transformT = performance.now();
+  const result = transformSchema(schema, ctx);
+  debug("Completed AST transformation for entire document", "ts", performance.now() - transformT);
+
+  return result;
+}

package/src/lib/redoc.ts

@@ -0,0 +1,164 @@
+import { performance } from "node:perf_hooks";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+import {
+  BaseResolver,
+  bundle,
+  type Document,
+  lintDocument,
+  makeDocumentFromString,
+  type NormalizedProblem,
+  type Config as RedoclyConfig,
+  Source,
+} from "@redocly/openapi-core";
+import parseJson from "parse-json";
+import type { OpenAPI3 } from "../types.js";
+import { debug, error, warn } from "./utils.js";
+
+export interface ValidateAndBundleOptions {
+  redoc: RedoclyConfig;
+  silent: boolean;
+  cwd?: URL;
+}
+
+interface ParseSchemaOptions {
+  absoluteRef: string;
+  resolver: BaseResolver;
+}
+
+export async function parseSchema(schema: unknown, { absoluteRef, resolver }: ParseSchemaOptions): Promise<Document> {
+  if (!schema) {
+    throw new Error("Can’t parse empty schema");
+  }
+  if (schema instanceof URL) {
+    const result = await resolver.resolveDocument(null, absoluteRef, true);
+    if ("parsed" in result) {
+      return result;
+    }
+    throw result.originalError;
+  }
+  if (schema instanceof Readable) {
+    const contents = await new Promise<string>((resolve) => {
+      schema.resume();
+      schema.setEncoding("utf8");
+      let content = "";
+      schema.on("data", (chunk: string) => {
+        content += chunk;
+      });
+      schema.on("end", () => {
+        resolve(content.trim());
+      });
+    });
+    return parseSchema(contents, { absoluteRef, resolver });
+  }
+  if (schema instanceof Buffer) {
+    return parseSchema(schema.toString("utf8"), { absoluteRef, resolver });
+  }
+  if (typeof schema === "string") {
+    // URL
+    if (schema.startsWith("http://") || schema.startsWith("https://") || schema.startsWith("file://")) {
+      const url = new URL(schema);
+      return parseSchema(url, {
+        absoluteRef: url.protocol === "file:" ? fileURLToPath(url) : url.href,
+        resolver,
+      });
+    }
+    // JSON
+    if (schema[0] === "{") {
+      return {
+        source: new Source(absoluteRef, schema, "application/json"),
+        parsed: parseJson(schema),
+      };
+    }
+    // YAML
+    return makeDocumentFromString(schema, absoluteRef);
+  }
+  if (typeof schema === "object" && !Array.isArray(schema)) {
+    return {
+      source: new Source(absoluteRef, JSON.stringify(schema), "application/json"),
+      parsed: schema,
+    };
+  }
+  throw new Error(`Expected string, object, or Buffer. Got ${Array.isArray(schema) ? "Array" : typeof schema}`);
+}
+
+function _processProblems(problems: NormalizedProblem[], options: { silent: boolean }) {
+  if (problems.length) {
+    let errorMessage: string | undefined;
+    for (const problem of problems) {
+      const problemLocation = problem.location?.[0].pointer;
+      const problemMessage = problemLocation ? `${problem.message} at ${problemLocation}` : problem.message;
+      if (problem.severity === "error") {
+        errorMessage = problemMessage;
+        error(problemMessage);
+      } else {
+        warn(problemMessage, options.silent);
+      }
+    }
+    if (errorMessage) {
+      throw new Error(errorMessage);
+    }
+  }
+}
+
+/**
+ * Validate an OpenAPI schema and flatten into a single schema using Redocly CLI
+ */
+export async function validateAndBundle(
+  source: string | URL | OpenAPI3 | Readable | Buffer,
+  options: ValidateAndBundleOptions,
+) {
+  const redocConfigT = performance.now();
+  debug("Loaded Redoc config", "redoc", performance.now() - redocConfigT);
+  const redocParseT = performance.now();
+  let absoluteRef = fileURLToPath(new URL(options?.cwd ?? `file://${process.cwd()}/`));
+  if (source instanceof URL) {
+    absoluteRef = source.protocol === "file:" ? fileURLToPath(source) : source.href;
+  }
+  const resolver = new BaseResolver(options.redoc.resolve);
+  const document = await parseSchema(source, {
+    absoluteRef,
+    resolver,
+  });
+  debug("Parsed schema", "redoc", performance.now() - redocParseT);
+
+  // 1. check for OpenAPI 3 or greater
+  const openapiVersion = Number.parseFloat(document.parsed.openapi);
+  if (
+    document.parsed.swagger ||
+    !document.parsed.openapi ||
+    Number.isNaN(openapiVersion) ||
+    openapiVersion < 3 ||
+    openapiVersion >= 4
+  ) {
+    if (document.parsed.swagger) {
+      throw new Error("Unsupported Swagger version: 2.x. Use OpenAPI 3.x instead.");
+    }
+    if (document.parsed.openapi || openapiVersion < 3 || openapiVersion >= 4) {
+      throw new Error(`Unsupported OpenAPI version: ${document.parsed.openapi}`);
+    }
+    throw new Error("Unsupported schema format, expected `openapi: 3.x`");
+  }
+
+  // 2. lint
+  const redocLintT = performance.now();
+  const problems = await lintDocument({
+    document,
+    config: options.redoc.styleguide,
+    externalRefResolver: resolver,
+  });
+  _processProblems(problems, options);
+  debug("Linted schema", "lint", performance.now() - redocLintT);
+
+  // 3. bundle
+  const redocBundleT = performance.now();
+  const bundled = await bundle({
+    config: options.redoc,
+    dereference: false,
+    doc: document,
+  });
+  _processProblems(bundled.problems, options);
+  debug("Bundled schema", "bundle", performance.now() - redocBundleT);
+
+  return bundled.bundle.parsed;
+}