@kubb/plugin-msw 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/types-C6GF3XKm.d.ts

@@ -0,0 +1,64 @@
+import { PluginFactoryOptions, Output, ResolveNameParams } from '@kubb/core';
+import { ResolvePathOptions, Exclude, Include, Override, Generator } from '@kubb/plugin-oas';
+
+type Options = {
+    /**
+     * @default 'mocks'
+     */
+    output?: Output;
+    /**
+     * Group the MSW mocks based on the provided name.
+     */
+    group?: {
+        /**
+         * Tag will group based on the operation tag inside the Swagger file
+         */
+        type: 'tag';
+        /**
+         * Relative path to save the grouped MSW mocks.
+         *
+         * `{{tag}}` will be replaced by the current tagName.
+         * @example `${output}/{{tag}}Controller` => `mocks/PetController`
+         * @default `${output}/{{tag}}Controller`
+         */
+        output?: string;
+        /**
+         * Name to be used for the `export * as {{exportAs}} from './`
+         * @default `"{{tag}}Handlers"`
+         */
+        exportAs?: string;
+    };
+    /**
+     * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+     */
+    exclude?: Array<Exclude>;
+    /**
+     * Array containing include parameters to include tags/operations/methods/paths.
+     */
+    include?: Array<Include>;
+    /**
+     * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+     */
+    override?: Array<Override<ResolvedOptions>>;
+    transformers?: {
+        /**
+         * Customize the names based on the type that is provided by the plugin.
+         */
+        name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    };
+    /**
+     * Create `handlers.ts` file with all handlers for all mocks.
+     * @default `false`
+     */
+    handlers?: boolean;
+    /**
+     * Define some generators next to the msw generators
+     */
+    generators?: Array<Generator<PluginMsw>>;
+};
+type ResolvedOptions = {
+    output: Output;
+};
+type PluginMsw = PluginFactoryOptions<'plugin-msw', Options, ResolvedOptions, never, ResolvePathOptions>;
+
+export type { Options as O, PluginMsw as P };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-msw",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.30",
   "description": "Generator swagger",
   "keywords": [
     "typescript",
@@ -40,6 +40,11 @@
       "require": "./dist/components.cjs",
       "default": "./dist/components.cjs"
     },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs",
+      "default": "./dist/generators.cjs"
+    },
     "./package.json": "./package.json",
     "./*": "./*"
   },
@@ -56,6 +61,9 @@
       ],
       "components": [
         "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
       ]
     }
   },
@@ -66,27 +74,24 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "@kubb/core": "3.0.0-alpha.3",
-    "@kubb/fs": "3.0.0-alpha.3",
-    "@kubb/oas": "3.0.0-alpha.3",
-    "@kubb/parser-ts": "3.0.0-alpha.3",
-    "@kubb/plugin-faker": "3.0.0-alpha.3",
-    "@kubb/plugin-oas": "3.0.0-alpha.3",
-    "@kubb/plugin-ts": "3.0.0-alpha.3",
-    "@kubb/react": "3.0.0-alpha.3"
+    "@kubb/core": "3.0.0-alpha.30",
+    "@kubb/fs": "3.0.0-alpha.30",
+    "@kubb/oas": "3.0.0-alpha.30",
+    "@kubb/plugin-faker": "3.0.0-alpha.30",
+    "@kubb/plugin-oas": "3.0.0-alpha.30",
+    "@kubb/plugin-ts": "3.0.0-alpha.30",
+    "@kubb/react": "3.0.0-alpha.30"
   },
   "devDependencies": {
-    "@types/react": "^18.3.4",
-    "@types/react-dom": "^18.3.0",
+    "@types/react": "^18.3.10",
     "react": "^18.3.1",
-    "tsup": "^8.2.4",
-    "typescript": "^5.5.4",
-    "@kubb/config-biome": "3.0.0-alpha.3",
-    "@kubb/config-ts": "3.0.0-alpha.3",
-    "@kubb/config-tsup": "3.0.0-alpha.3"
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
+    "@kubb/config-ts": "3.0.0-alpha.30",
+    "@kubb/config-tsup": "3.0.0-alpha.30"
   },
   "peerDependencies": {
-    "@kubb/react": "3.0.0-alpha.3"
+    "@kubb/react": "3.0.0-alpha.30"
   },
   "engines": {
     "node": ">=20"

package/src/components/Handlers.tsx

@@ -0,0 +1,19 @@
+import { File } from '@kubb/react'
+import type { ReactNode } from 'react'
+
+type HandlersProps = {
+  /**
+   * Name of the function
+   */
+  name: string
+  // custom
+  handlers: string[]
+}
+
+export function Handlers({ name, handlers }: HandlersProps): ReactNode {
+  return (
+    <File.Source name={name} isIndexable isExportable>
+      {`export const ${name} = ${JSON.stringify(handlers).replaceAll(`"`, '')} as const`}
+    </File.Source>
+  )
+}

package/src/components/Mock.tsx

@@ -1,113 +1,30 @@
-import { PackageManager } from '@kubb/core'
-import { URLPath } from '@kubb/core/utils'
-import { Parser, File, useApp } from '@kubb/react'
-import { pluginFakerName } from '@kubb/plugin-faker'
-import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
+import { File } from '@kubb/react'
 
 import type { HttpMethod } from '@kubb/oas'
 import type { ReactNode } from 'react'
-import type { FileMeta, PluginMsw } from '../types.ts'
 
-type TemplateProps = {
+type Props = {
   /**
    * Name of the function
    */
   name: string
-  /**
-   * Method of the current operation, see useOperation.
-   */
+  fakerName: string
+  url: string
   method: HttpMethod
-  /**
-   * Path of the mock
-   */
-  path: URLPath
-  /**
-   * Name of the import for the mock(this is a function).
-   * @example createPet
-   */
-  responseName: string
 }
 
-function Template({ name, method, path, responseName }: TemplateProps): ReactNode {
+export function Mock({ name, fakerName, url, method }: Props): ReactNode {
   return (
-    <>
+    <File.Source name={name} isIndexable isExportable>
       {`
-  export const ${name} = http.${method}('*${path.toURLPath()}', function handler(info) {
-    return new Response(JSON.stringify(${responseName}()), {
+  export const ${name} = http.${method}('*${url}', function handler(info) {
+    return new Response(JSON.stringify(${fakerName}()), {
       headers: {
         'Content-Type': 'application/json',
       },
     })
   })
   `}
-    </>
+    </File.Source>
   )
 }
-
-const defaultTemplates = { default: Template } as const
-
-type Props = {
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  Template?: React.ComponentType<React.ComponentProps<typeof Template>>
-}
-
-export function Mock({ Template = defaultTemplates.default }: Props): ReactNode {
-  const { pluginManager } = useApp<PluginMsw>()
-  const { getSchemas, getName } = useOperationManager()
-  const operation = useOperation()
-
-  const schemas = getSchemas(operation)
-  const name = getName(operation, { type: 'function' })
-  const responseName = pluginManager.resolveName({
-    pluginKey: [pluginFakerName],
-    name: schemas.response.name,
-    type: 'type',
-  })
-
-  return <Template name={name} responseName={responseName} method={operation.method} path={new URLPath(operation.path)} />
-}
-
-type FileProps = {
-  /**
-   * This will make it possible to override the default behaviour.
-   */
-  templates?: typeof defaultTemplates
-}
-
-Mock.File = function ({ templates = defaultTemplates }: FileProps): ReactNode {
-  const {
-    pluginManager,
-    plugin: {
-      options: { extName },
-    },
-  } = useApp<PluginMsw>()
-  const { getSchemas, getFile } = useOperationManager()
-  const operation = useOperation()
-
-  const schemas = getSchemas(operation)
-  const file = getFile(operation)
-  const fileFaker = getFile(operation, { pluginKey: [pluginFakerName] })
-  const responseName = pluginManager.resolveName({
-    pluginKey: [pluginFakerName],
-    name: schemas.response.name,
-    type: 'function',
-  })
-
-  const Template = templates.default
-
-  return (
-    <Parser language="typescript">
-      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-        <File.Import name={['http']} path={'msw'} />
-        {fileFaker && responseName && <File.Import extName={extName} name={[responseName]} root={file.path} path={fileFaker.path} />}
-        <File.Source>
-          <Mock Template={Template} />
-        </File.Source>
-      </File>
-    </Parser>
-  )
-}
-
-Mock.templates = defaultTemplates

package/src/components/index.ts

@@ -1,2 +1,2 @@
 export { Mock } from './Mock.tsx'
-export { Operations } from './Operations.tsx'
+export { Handlers } from './Handlers.tsx'

package/src/generators/__snapshots__/createPet.ts

@@ -0,0 +1,9 @@
+import { http } from "msw";
+
+ export const createPets = http.post("*/pets", function handler(info) {
+    return new Response(JSON.stringify(createPetsMutationResponse()), {
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+});

package/src/generators/__snapshots__/deletePet.ts

@@ -0,0 +1,9 @@
+import { http } from "msw";
+
+ export const deletePetsPetid = http.delete("*/pets/:petId", function handler(info) {
+    return new Response(JSON.stringify(deletePetsPetidMutationResponse()), {
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+});

package/src/generators/__snapshots__/getPets.ts

@@ -0,0 +1,9 @@
+import { http } from "msw";
+
+ export const listPets = http.get("*/pets", function handler(info) {
+    return new Response(JSON.stringify(listPetsQueryResponse()), {
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+});

package/src/generators/__snapshots__/handlers.ts

@@ -0,0 +1,3 @@
+import { listPets, createPets, showPetById } from "./findByTags";
+
+ export const handlers = [listPets, createPets, showPetById] as const;

package/src/generators/__snapshots__/showPetById.ts

@@ -0,0 +1,9 @@
+import { http } from "msw";
+
+ export const showPetById = http.get("*/pets/:petId", function handler(info) {
+    return new Response(JSON.stringify(showPetByIdQueryResponse()), {
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+});

package/src/generators/handlersGenerator.tsx

@@ -0,0 +1,32 @@
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { File, useApp } from '@kubb/react'
+import { Handlers } from '../components/Handlers.tsx'
+import { pluginMswName } from '../plugin.ts'
+import type { PluginMsw } from '../types'
+
+export const handlersGenerator = createReactGenerator<PluginMsw>({
+  name: 'plugin-msw',
+  Operations({ operations }) {
+    const { pluginManager, plugin } = useApp<PluginMsw>()
+    const { getName, getFile } = useOperationManager()
+
+    const file = pluginManager.getFile({ name: 'handlers', extname: '.ts', pluginKey: [pluginMswName] })
+
+    const imports = operations.map((operation) => {
+      const operationFile = getFile(operation, { pluginKey: [pluginMswName] })
+      const operationName = getName(operation, { pluginKey: [pluginMswName], type: 'function' })
+
+      return <File.Import key={operationFile.path} name={[operationName]} root={file.path} path={operationFile.path} />
+    })
+
+    const handlers = operations.map((operation) => getName(operation, { type: 'function', pluginKey: [pluginMswName] }))
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={plugin.options.output?.banner} footer={plugin.options.output?.footer}>
+        {imports}
+        <Handlers name={'handlers'} handlers={handlers} />
+      </File>
+    )
+  },
+})

package/src/generators/index.ts

@@ -0,0 +1,2 @@
+export { mswGenerator } from './mswGenerator.tsx'
+export { handlersGenerator } from './handlersGenerator.tsx'

package/src/generators/mswGenerator.tsx

@@ -0,0 +1,38 @@
+import { URLPath } from '@kubb/core/utils'
+import { pluginFakerName } from '@kubb/plugin-faker'
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { File, useApp } from '@kubb/react'
+import { Mock } from '../components'
+import type { PluginMsw } from '../types'
+
+export const mswGenerator = createReactGenerator<PluginMsw>({
+  name: 'msw',
+  Operation({ operation }) {
+    const {
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginMsw>()
+    const { getSchemaName, getName, getFile } = useOperationManager()
+
+    const mock = {
+      name: getName(operation, { type: 'function' }),
+      file: getFile(operation),
+    }
+
+    const faker = {
+      name: getSchemaName(operation, 'response', { pluginKey: [pluginFakerName], type: 'function' }),
+      file: getFile(operation, { pluginKey: [pluginFakerName] }),
+    }
+
+    return (
+      <File baseName={mock.file.baseName} path={mock.file.path} meta={mock.file.meta} banner={output?.banner} footer={output?.footer}>
+        <File.Import name={['http']} path={'msw'} />
+        {faker.file && faker.name && <File.Import name={[faker.name]} root={mock.file.path} path={faker.file.path} />}
+
+        <Mock name={mock.name} fakerName={faker.name} method={operation.method} url={new URLPath(operation.path).toURLPath()} />
+      </File>
+    )
+  },
+})

package/src/plugin.ts

@@ -3,33 +3,35 @@ import path from 'node:path'
 import { FileManager, PluginManager, createPlugin } from '@kubb/core'
 import { camelCase } from '@kubb/core/transformers'
 import { renderTemplate } from '@kubb/core/utils'
-import { pluginOasName } from '@kubb/plugin-oas'
-import { getGroupedByTagFiles } from '@kubb/plugin-oas/utils'
+import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
+
 import { pluginFakerName } from '@kubb/plugin-faker'
 import { pluginTsName } from '@kubb/plugin-ts'
 
-import { OperationGenerator } from './OperationGenerator.tsx'
-import { Mock, Operations } from './components/index.ts'
-
 import type { Plugin } from '@kubb/core'
 import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
+import { handlersGenerator, mswGenerator } from './generators'
 import type { PluginMsw } from './types.ts'
 
 export const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']
 
 export const pluginMsw = createPlugin<PluginMsw>((options) => {
-  const { output = { path: 'handlers' }, group, exclude = [], include, override = [], transformers = {}, templates } = options
+  const {
+    output = { path: 'handlers', barrelType: 'named' },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    transformers = {},
+    handlers = false,
+    generators = [mswGenerator, handlers ? handlersGenerator : undefined].filter(Boolean),
+  } = options
   const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
 
   return {
     name: pluginMswName,
     options: {
-      extName: output.extName,
-      templates: {
-        operations: Operations.templates,
-        mock: Mock.templates,
-        ...templates,
-      },
+      output,
     },
     pre: [pluginOasName, pluginTsName, pluginFakerName],
     resolvePath(baseName, pathMode, options) {
@@ -57,6 +59,7 @@ export const pluginMsw = createPlugin<PluginMsw>((options) => {
         suffix: type ? 'handler' : undefined,
         isFile: type === 'file',
       })
+
       if (type) {
         return transformers?.name?.(resolvedName, type) || resolvedName
       }
@@ -81,36 +84,21 @@ export const pluginMsw = createPlugin<PluginMsw>((options) => {
         mode,
       })
 
-      const files = await operationGenerator.build()
+      const files = await operationGenerator.build(...generators)
       await this.addFile(...files)
-    },
-    async buildEnd() {
-      if (this.config.output.write === false) {
-        return
-      }
 
-      const root = path.resolve(this.config.root, this.config.output.path)
-
-      if (group?.type === 'tag') {
-        const rootFiles = await getGroupedByTagFiles({
-          logger: this.logger,
-          files: this.fileManager.files,
-          plugin: this.plugin,
-          template,
-          exportAs: group.exportAs || '{{tag}}Handlers',
-          root,
-          output,
-        })
-
-        await this.addFile(...rootFiles)
-      }
-
-      await this.fileManager.addIndexes({
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
         root,
         output,
-        meta: { pluginKey: this.plugin.key },
+        files: this.fileManager.files,
+        meta: {
+          pluginKey: this.plugin.key,
+        },
         logger: this.logger,
       })
+
+      await this.addFile(...barrelFiles)
     },
   }
 })

package/src/types.ts

@@ -1,36 +1,12 @@
-import type { Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type * as KubbFile from '@kubb/fs/types'
+import type { Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { Mock, Operations } from './components/index.ts'
-
-type Templates = {
-  operations?: typeof Operations.templates | false
-  mock?: typeof Mock.templates | false
-}
+import type { Exclude, Generator, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
 
 export type Options = {
-  output?: {
-    /**
-     * Relative path to save the MSW mocks.
-     * When output is a file it will save all models inside that file else it will create a file per schema item.
-     * @default 'mocks'
-     */
-    path: string
-    /**
-     * Name to be used for the `export * as {{exportAs}} from './'`
-     */
-    exportAs?: string
-    /**
-     * Add an extension to the generated imports and exports, default it will not use an extension
-     */
-    extName?: KubbFile.Extname
-    /**
-     * Define what needs to exported, here you can also disable the export of barrel files
-     * @default `'barrel'`
-     */
-    exportType?: 'barrel' | 'barrelNamed' | false
-  }
+  /**
+   * @default 'mocks'
+   */
+  output?: Output
   /**
    * Group the MSW mocks based on the provided name.
    */
@@ -72,18 +48,17 @@ export type Options = {
     name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
   }
   /**
-   * Make it possible to override one of the templates
+   * Create `handlers.ts` file with all handlers for all mocks.
+   * @default `false`
    */
-  templates?: Partial<Templates>
+  handlers?: boolean
+  /**
+   * Define some generators next to the msw generators
+   */
+  generators?: Array<Generator<PluginMsw>>
 }
 type ResolvedOptions = {
-  extName: KubbFile.Extname | undefined
-  templates: NonNullable<Templates>
-}
-
-export type FileMeta = {
-  pluginKey?: Plugin['key']
-  tag?: string
+  output: Output
 }
 
 export type PluginMsw = PluginFactoryOptions<'plugin-msw', Options, ResolvedOptions, never, ResolvePathOptions>