@depup/openapi-typescript 7.13.0-depup.0

package/src/transform/request-body-object.ts

@@ -0,0 +1,59 @@
+import ts from "typescript";
+import { addJSDocComment, NEVER, QUESTION_TOKEN, tsModifiers, tsPropertyIndex } from "../lib/ts.js";
+import { createRef, getEntries } from "../lib/utils.js";
+import type { RequestBodyObject, TransformNodeOptions } from "../types.js";
+import transformMediaTypeObject from "./media-type-object.js";
+import transformSchemaObject from "./schema-object.js";
+
+/**
+ * Transform RequestBodyObject nodes (4.8.13)
+ * @see https://spec.openapis.org/oas/v3.1.0#request-body-object
+ */
+export default function transformRequestBodyObject(
+  requestBodyObject: RequestBodyObject,
+  options: TransformNodeOptions,
+): ts.TypeNode {
+  const type: ts.TypeElement[] = [];
+  for (const [contentType, mediaTypeObject] of getEntries(requestBodyObject.content ?? {}, options.ctx)) {
+    const nextPath = createRef([options.path, "content", contentType]);
+    const mediaType =
+      "$ref" in mediaTypeObject
+        ? transformSchemaObject(mediaTypeObject, {
+            ...options,
+            path: nextPath,
+          })
+        : transformMediaTypeObject(mediaTypeObject, {
+            ...options,
+            path: nextPath,
+          });
+    const property = ts.factory.createPropertySignature(
+      /* modifiers     */ tsModifiers({ readonly: options.ctx.immutable }),
+      /* name          */ tsPropertyIndex(contentType),
+      /* questionToken */ undefined,
+      /* type          */ mediaType,
+    );
+    addJSDocComment(mediaTypeObject, property);
+    type.push(property);
+  }
+
+  return ts.factory.createTypeLiteralNode([
+    ts.factory.createPropertySignature(
+      /* modifiers     */ tsModifiers({ readonly: options.ctx.immutable }),
+      /* name          */ tsPropertyIndex("content"),
+      /* questionToken */ undefined,
+      /* type          */ ts.factory.createTypeLiteralNode(
+        type.length
+          ? type
+          : // add `"*/*": never` if no media types are defined
+            [
+              ts.factory.createPropertySignature(
+                /* modifiers     */ undefined,
+                /* name          */ tsPropertyIndex("*/*"),
+                /* questionToken */ QUESTION_TOKEN,
+                /* type          */ NEVER,
+              ),
+            ],
+      ),
+    ),
+  ]);
+}

package/src/transform/response-object.ts

@@ -0,0 +1,112 @@
+import ts from "typescript";
+import {
+  addJSDocComment,
+  NEVER,
+  oapiRef,
+  QUESTION_TOKEN,
+  STRING,
+  tsModifiers,
+  tsPropertyIndex,
+  UNKNOWN,
+} from "../lib/ts.js";
+import { createRef, getEntries } from "../lib/utils.js";
+import type { ResponseObject, TransformNodeOptions } from "../types.js";
+import transformHeaderObject from "./header-object.js";
+import transformMediaTypeObject from "./media-type-object.js";
+
+/**
+ * Transform ResponseObject nodes (4.8.17)
+ * @see https://spec.openapis.org/oas/v3.1.0#response-object
+ */
+export default function transformResponseObject(
+  responseObject: ResponseObject,
+  options: TransformNodeOptions,
+): ts.TypeNode {
+  const type: ts.TypeElement[] = [];
+
+  // headers
+  const headersObject: ts.TypeElement[] = [];
+  if (responseObject.headers) {
+    for (const [name, headerObject] of getEntries(responseObject.headers, options.ctx)) {
+      const optional = "$ref" in headerObject || headerObject.required ? undefined : QUESTION_TOKEN;
+      const subType =
+        "$ref" in headerObject
+          ? oapiRef(headerObject.$ref)
+          : transformHeaderObject(headerObject, {
+              ...options,
+              path: createRef([options.path, "headers", name]),
+            });
+      const property = ts.factory.createPropertySignature(
+        /* modifiers     */ tsModifiers({ readonly: options.ctx.immutable }),
+        /* name          */ tsPropertyIndex(name),
+        /* questionToken */ optional,
+        /* type          */ subType,
+      );
+      addJSDocComment(headerObject, property);
+      headersObject.push(property);
+    }
+  }
+  // allow additional unknown headers
+  headersObject.push(
+    ts.factory.createIndexSignature(
+      /* modifiers     */ tsModifiers({ readonly: options.ctx.immutable }),
+      /* parameters */ [
+        ts.factory.createParameterDeclaration(
+          /* modifiers      */ undefined,
+          /* dotDotDotToken */ undefined,
+          /* name           */ ts.factory.createIdentifier("name"),
+          /* questionToken  */ undefined,
+          /* type           */ STRING,
+        ),
+      ],
+      /* type          */ UNKNOWN,
+    ),
+  );
+  type.push(
+    ts.factory.createPropertySignature(
+      /* modifiers     */ undefined,
+      /* name          */ tsPropertyIndex("headers"),
+      /* questionToken */ undefined,
+      /* type          */ ts.factory.createTypeLiteralNode(headersObject),
+    ),
+  );
+
+  // content
+  const contentObject: ts.TypeElement[] = [];
+  if (responseObject.content) {
+    for (const [contentType, mediaTypeObject] of getEntries(responseObject.content ?? {}, options.ctx)) {
+      const property = ts.factory.createPropertySignature(
+        /* modifiers     */ tsModifiers({ readonly: options.ctx.immutable }),
+        /* name          */ tsPropertyIndex(contentType),
+        /* questionToken */ undefined,
+        /* type          */ transformMediaTypeObject(mediaTypeObject, {
+          ...options,
+          path: createRef([options.path, "content", contentType]),
+        }),
+      );
+      addJSDocComment(mediaTypeObject, property);
+      contentObject.push(property);
+    }
+  }
+  if (contentObject.length) {
+    type.push(
+      ts.factory.createPropertySignature(
+        /* modifiers     */ undefined,
+        /* name          */ tsPropertyIndex("content"),
+        /* questionToken */ undefined,
+        /* type          */ ts.factory.createTypeLiteralNode(contentObject),
+      ),
+    );
+  } else {
+    type.push(
+      ts.factory.createPropertySignature(
+        /* modifiers     */ undefined,
+        /* name          */ tsPropertyIndex("content"),
+        /* questionToken */ QUESTION_TOKEN,
+        /* type          */ NEVER,
+      ),
+    );
+  }
+
+  return ts.factory.createTypeLiteralNode(type);
+}

package/src/transform/responses-object.ts

@@ -0,0 +1,36 @@
+import ts from "typescript";
+import { addJSDocComment, NEVER, oapiRef, tsModifiers, tsPropertyIndex } from "../lib/ts.js";
+import { createRef, getEntries } from "../lib/utils.js";
+import type { ResponsesObject, TransformNodeOptions } from "../types.js";
+import transformResponseObject from "./response-object.js";
+
+/**
+ * Transform ResponsesObject nodes (4.8.16)
+ * @see https://spec.openapis.org/oas/v3.1.0#responses-object
+ */
+export default function transformResponsesObject(
+  responsesObject: ResponsesObject,
+  options: TransformNodeOptions,
+): ts.TypeNode {
+  const type: ts.TypeElement[] = [];
+
+  for (const [responseCode, responseObject] of getEntries(responsesObject, options.ctx)) {
+    const responseType =
+      "$ref" in responseObject
+        ? oapiRef(responseObject.$ref)
+        : transformResponseObject(responseObject, {
+            ...options,
+            path: createRef([options.path, "responses", responseCode]),
+          });
+    const property = ts.factory.createPropertySignature(
+      /* modifiers     */ tsModifiers({ readonly: options.ctx.immutable }),
+      /* name          */ tsPropertyIndex(responseCode),
+      /* questionToken */ undefined,
+      /* type          */ responseType,
+    );
+    addJSDocComment(responseObject, property);
+    type.push(property);
+  }
+
+  return type.length ? ts.factory.createTypeLiteralNode(type) : NEVER;
+}