msw plugin

packages/openapi-ts/package.json

@@ -112,6 +112,7 @@
     "express": "4.21.0",
     "fastify": "5.2.0",
     "glob": "10.4.3",
+    "msw": "2.7.0",
     "node-fetch": "3.3.2",
     "nuxt": "3.15.1",
     "prettier": "3.4.2",

packages/openapi-ts/src/ir/operation.ts

@@ -97,6 +97,7 @@ interface OperationResponsesMap {
   responses?: IR.SchemaObject;
 }
 
+// TODO: handle multiple content types
 export const operationResponsesMap = (
   operation: IR.OperationObject,
 ): OperationResponsesMap => {

packages/openapi-ts/src/openApi/shared/types/schema.d.ts

@@ -20,6 +20,11 @@ export type SchemaWithRequired<
   [P in K]-?: S[P];
 };
 
+export interface SchemaWithType<T extends Required<IR.SchemaObject>['type']>
+  extends Omit<IR.SchemaObject, 'type'> {
+  type: Extract<Required<IR.SchemaObject>['type'], T>;
+}
+
 export type SchemaType<
   S extends {
     type?: unknown;

packages/openapi-ts/src/plugins/@hey-api/typescript/plugin.ts

@@ -5,6 +5,7 @@ import { compiler } from '../../../compiler';
 import { operationResponsesMap } from '../../../ir/operation';
 import { deduplicateSchema } from '../../../ir/schema';
 import type { IR } from '../../../ir/types';
+import type { SchemaWithType } from '../../../openApi/shared/types/schema';
 import { escapeComment } from '../../../utils/escape';
 import { irRef, isRefOpenApiComponent } from '../../../utils/ref';
 import { numberRegExp } from '../../../utils/regexp';
@@ -15,11 +16,6 @@ import type { Plugin } from '../../types';
 import { typesId } from './ref';
 import type { Config } from './types';
 
-interface SchemaWithType<T extends Required<IR.SchemaObject>['type']>
-  extends Omit<IR.SchemaObject, 'type'> {
-  type: Extract<Required<IR.SchemaObject>['type'], T>;
-}
-
 const parseSchemaJsDoc = ({ schema }: { schema: IR.SchemaObject }) => {
   const comments = [
     schema.description && escapeComment(schema.description),

packages/openapi-ts/src/plugins/index.ts

@@ -35,6 +35,7 @@ import {
   defaultConfig as tanStackVueQuery,
 } from './@tanstack/vue-query';
 import { type Config as Fastify, defaultConfig as fastify } from './fastify';
+import { type Config as Msw, defaultConfig as msw } from './msw';
 import type { DefaultPluginConfigs, Plugin } from './types';
 import { type Config as Zod, defaultConfig as zod } from './zod';
 
@@ -52,6 +53,7 @@ export type UserPlugins =
   | Plugin.UserConfig<TanStackSvelteQuery>
   | Plugin.UserConfig<TanStackVueQuery>
   | Plugin.UserConfig<Fastify>
+  | Plugin.UserConfig<Msw>
   | Plugin.UserConfig<Zod>;
 
 /**
@@ -68,6 +70,7 @@ export type ClientPlugins =
   | Plugin.Config<TanStackSvelteQuery>
   | Plugin.Config<TanStackVueQuery>
   | Plugin.Config<Fastify>
+  | Plugin.Config<Msw>
   | Plugin.Config<Zod>;
 
 export const defaultPluginConfigs: DefaultPluginConfigs<ClientPlugins> = {
@@ -81,5 +84,6 @@ export const defaultPluginConfigs: DefaultPluginConfigs<ClientPlugins> = {
   '@tanstack/svelte-query': tanStackSvelteQuery,
   '@tanstack/vue-query': tanStackVueQuery,
   fastify,
+  msw,
   zod,
 };

packages/openapi-ts/src/plugins/msw/config.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from '../types';
+import { handler } from './plugin';
+import type { Config } from './types';
+
+export const defaultConfig: Plugin.Config<Config> = {
+  _handler: handler,
+  _handlerLegacy: () => {},
+  name: 'msw',
+  output: 'msw',
+};
+
+/**
+ * Type helper for MSW plugin, returns {@link Plugin.Config} object
+ */
+export const defineConfig: Plugin.DefineConfig<Config> = (config) => ({
+  ...defaultConfig,
+  ...config,
+});

packages/openapi-ts/src/plugins/msw/index.ts

@@ -0,0 +1,2 @@
+export { defaultConfig, defineConfig } from './config';
+export type { Config } from './types';

packages/openapi-ts/src/plugins/msw/interfaces.ts

@@ -0,0 +1,126 @@
+import ts from 'typescript';
+
+import { compiler } from '../../compiler';
+
+const objectReference = compiler.typeReferenceNode({ typeName: 'object' });
+const tReference = compiler.typeReferenceNode({ typeName: 'T' });
+const uReference = compiler.typeReferenceNode({ typeName: 'U' });
+export const undefinedReference = compiler.typeReferenceNode({
+  typeName: 'undefined',
+});
+export const neverReference = compiler.typeReferenceNode({ typeName: 'never' });
+
+export const pathParamsTypeName = 'PathParams';
+export const responseBodyTypeTypeName = 'ResponseBodyType';
+const transformObjectTypeName = 'TransformObject';
+
+export const createTransformObjectType = () => {
+  const tkType = compiler.indexedAccessTypeNode({
+    indexType: compiler.typeReferenceNode({ typeName: 'K' }),
+    objectType: tReference,
+  });
+  const nullType = compiler.literalTypeNode({ literal: compiler.null() });
+  const type = compiler.typeAliasDeclaration({
+    name: transformObjectTypeName,
+    type: compiler.mappedTypeNode({
+      type: ts.factory.createConditionalTypeNode(
+        tkType,
+        objectReference,
+        compiler.typeReferenceNode({
+          typeArguments: [tkType],
+          typeName: transformObjectTypeName,
+        }),
+        compiler.typeUnionNode({
+          types: [
+            compiler.typeReferenceNode({ typeName: 'string' }),
+            ts.factory.createConditionalTypeNode(
+              nullType,
+              tkType,
+              undefinedReference,
+              neverReference,
+            ),
+          ],
+        }),
+      ),
+      typeParameter: compiler.typeParameterDeclaration({
+        constraint: compiler.typeOperatorNode({
+          operator: 'keyof',
+          type: tReference,
+        }),
+        name: 'K',
+      }),
+    }),
+    typeParameters: [
+      compiler.typeParameterDeclaration({
+        name: 'T',
+      }),
+    ],
+  });
+  return type;
+};
+
+export const createPathParamsType = () => {
+  const type = compiler.typeAliasDeclaration({
+    name: pathParamsTypeName,
+    type: ts.factory.createConditionalTypeNode(
+      tReference,
+      ts.factory.createTypeLiteralNode([
+        ts.factory.createPropertySignature(
+          undefined,
+          ts.factory.createIdentifier('path'),
+          ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+          ts.factory.createInferTypeNode(
+            compiler.typeParameterDeclaration({
+              name: 'U',
+            }),
+          ),
+        ),
+      ]),
+      ts.factory.createConditionalTypeNode(
+        uReference,
+        objectReference,
+        compiler.typeReferenceNode({
+          typeArguments: [uReference],
+          typeName: transformObjectTypeName,
+        }),
+        neverReference,
+      ),
+      neverReference,
+    ),
+    typeParameters: [
+      compiler.typeParameterDeclaration({
+        name: 'T',
+      }),
+    ],
+  });
+  return type;
+};
+
+export const createResponseBodyTypeType = () => {
+  const type = compiler.typeAliasDeclaration({
+    name: responseBodyTypeTypeName,
+    type: ts.factory.createConditionalTypeNode(
+      compiler.typeReferenceNode({ typeName: 'void' }),
+      tReference,
+      compiler.typeUnionNode({
+        types: [
+          compiler.typeReferenceNode({
+            typeArguments: [
+              tReference,
+              compiler.keywordTypeNode({ keyword: 'void' }),
+            ],
+            typeName: 'Exclude',
+          }),
+          undefinedReference,
+        ],
+      }),
+      tReference,
+    ),
+    typeParameters: [
+      compiler.typeParameterDeclaration({
+        name: 'T',
+      }),
+    ],
+  });
+  return type;
+};