@kubb/plugin-swr 0.0.0-canary-20241104172400

package/src/generators/__snapshots__/findByTagsWithZod.ts

@@ -0,0 +1,49 @@
+import client from "@kubb/plugin-client/client";
+import useSWR from "swr";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ export const findPetsByTagsQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
+
+ export type FindPetsByTagsQueryKey = ReturnType<typeof findPetsByTagsQueryKey>;
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+async function findPetsByTags({ params }: {
+    params?: FindPetsByTagsQueryParams;
+}, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "GET", url: `/pet/findByTags`, params, ...config });
+    return findPetsByTagsQueryResponse.parse(res.data);
+}
+
+ export function findPetsByTagsQueryOptions({ params }: {
+    params?: FindPetsByTagsQueryParams;
+}, config: Partial<RequestConfig> = {}) {
+    return {
+        fetcher: async () => {
+            return findPetsByTags({ params }, config);
+        },
+    };
+}
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export function useFindPetsByTags({ params }: {
+    params?: FindPetsByTagsQueryParams;
+}, options: {
+    query?: Parameters<typeof useSWR<FindPetsByTagsQueryResponse, FindPetsByTags400, FindPetsByTagsQueryKey | null, any>>[2];
+    client?: Partial<RequestConfig>;
+    shouldFetch?: boolean;
+} = {}) {
+    const { query: queryOptions, client: config = {}, shouldFetch = true } = options ?? {};
+    const queryKey = findPetsByTagsQueryKey(params);
+    return useSWR<FindPetsByTagsQueryResponse, FindPetsByTags400, FindPetsByTagsQueryKey | null>(shouldFetch ? queryKey : null, {
+        ...findPetsByTagsQueryOptions({ params }, config),
+        ...queryOptions
+    });
+}

package/src/generators/__snapshots__/getAsMutation.ts

@@ -0,0 +1,34 @@
+import client from "@kubb/plugin-client/client";
+import useSWRMutation from "custom-swr/mutation";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ export const findPetsByTagsMutationKey = () => [{ "url": "/pet/findByTags" }] as const;
+
+ export type FindPetsByTagsMutationKey = ReturnType<typeof findPetsByTagsMutationKey>;
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+async function findPetsByTags(params?: FindPetsByTagsQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<FindPetsByTagsQueryResponse, FindPetsByTags400, unknown>({ method: "GET", url: `/pet/findByTags`, params, ...config });
+    return res.data;
+}
+
+ /**
+ * @description Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+ * @summary Finds Pets by tags
+ * @link /pet/findByTags
+ */
+export function useFindPetsByTags(params?: FindPetsByTagsQueryParams, options: {
+    mutation?: Parameters<typeof useSWRMutation<FindPetsByTagsQueryResponse, FindPetsByTags400, FindPetsByTagsMutationKey>>[2];
+    client?: Partial<RequestConfig>;
+    shouldFetch?: boolean;
+} = {}) {
+    const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {};
+    const mutationKey = findPetsByTagsMutationKey();
+    return useSWRMutation<FindPetsByTagsQueryResponse, FindPetsByTags400, FindPetsByTagsMutationKey | null>(shouldFetch ? mutationKey : null, async (_url) => {
+        return findPetsByTags(params, config);
+    }, mutationOptions);
+}

package/src/generators/__snapshots__/postAsQuery.ts

@@ -0,0 +1,50 @@
+import client from "@kubb/plugin-client/client";
+import useSWR from "custom-swr";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ export const updatePetWithFormQueryKey = (petId: UpdatePetWithFormPathParams["petId"], params?: UpdatePetWithFormQueryParams) => [{ url: "/pet/:petId", params: { petId: petId } }, ...(params ? [params] : [])] as const;
+
+ export type UpdatePetWithFormQueryKey = ReturnType<typeof updatePetWithFormQueryKey>;
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+async function updatePetWithForm({ petId, params }: {
+    petId: UpdatePetWithFormPathParams["petId"];
+    params?: UpdatePetWithFormQueryParams;
+}, config: Partial<RequestConfig> = {}) {
+    const res = await client<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, unknown>({ method: "POST", url: `/pet/${petId}`, params, ...config });
+    return res.data;
+}
+
+ export function updatePetWithFormQueryOptions({ petId, params }: {
+    petId: UpdatePetWithFormPathParams["petId"];
+    params?: UpdatePetWithFormQueryParams;
+}, config: Partial<RequestConfig> = {}) {
+    return {
+        fetcher: async () => {
+            return updatePetWithForm({ petId, params }, config);
+        },
+    };
+}
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+export function useUpdatePetWithForm({ petId, params }: {
+    petId: UpdatePetWithFormPathParams["petId"];
+    params?: UpdatePetWithFormQueryParams;
+}, options: {
+    query?: Parameters<typeof useSWR<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormQueryKey | null, any>>[2];
+    client?: Partial<RequestConfig>;
+    shouldFetch?: boolean;
+} = {}) {
+    const { query: queryOptions, client: config = {}, shouldFetch = true } = options ?? {};
+    const queryKey = updatePetWithFormQueryKey(petId, params);
+    return useSWR<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormQueryKey | null>(shouldFetch ? queryKey : null, {
+        ...updatePetWithFormQueryOptions({ petId, params }, config),
+        ...queryOptions
+    });
+}

package/src/generators/__snapshots__/updatePetById.ts

@@ -0,0 +1,32 @@
+import client from "@kubb/plugin-client/client";
+import useSWRMutation from "swr/mutation";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ export const updatePetWithFormMutationKey = () => [{ "url": "/pet/{petId}" }] as const;
+
+ export type UpdatePetWithFormMutationKey = ReturnType<typeof updatePetWithFormMutationKey>;
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+async function updatePetWithForm(petId: UpdatePetWithFormPathParams["petId"], params?: UpdatePetWithFormQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, unknown>({ method: "POST", url: `/pet/${petId}`, params, ...config });
+    return res.data;
+}
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+export function useUpdatePetWithForm(petId: UpdatePetWithFormPathParams["petId"], params?: UpdatePetWithFormQueryParams, options: {
+    mutation?: Parameters<typeof useSWRMutation<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormMutationKey>>[2];
+    client?: Partial<RequestConfig>;
+    shouldFetch?: boolean;
+} = {}) {
+    const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {};
+    const mutationKey = updatePetWithFormMutationKey();
+    return useSWRMutation<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormMutationKey | null>(shouldFetch ? mutationKey : null, async (_url) => {
+        return updatePetWithForm(petId, params, config);
+    }, mutationOptions);
+}

package/src/generators/__snapshots__/updatePetByIdPathParamsObject.ts

@@ -0,0 +1,34 @@
+import client from "@kubb/plugin-client/client";
+import useSWRMutation from "swr/mutation";
+import type { RequestConfig } from "@kubb/plugin-client/client";
+
+ export const updatePetWithFormMutationKey = () => [{ "url": "/pet/{petId}" }] as const;
+
+ export type UpdatePetWithFormMutationKey = ReturnType<typeof updatePetWithFormMutationKey>;
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+async function updatePetWithForm({ petId }: UpdatePetWithFormPathParams, params?: UpdatePetWithFormQueryParams, config: Partial<RequestConfig> = {}) {
+    const res = await client<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, unknown>({ method: "POST", url: `/pet/${petId}`, params, ...config });
+    return res.data;
+}
+
+ /**
+ * @summary Updates a pet in the store with form data
+ * @link /pet/:petId
+ */
+export function useUpdatePetWithForm({ petId }: {
+    petId: UpdatePetWithFormPathParams["petId"];
+}, params?: UpdatePetWithFormQueryParams, options: {
+    mutation?: Parameters<typeof useSWRMutation<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormMutationKey>>[2];
+    client?: Partial<RequestConfig>;
+    shouldFetch?: boolean;
+} = {}) {
+    const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {};
+    const mutationKey = updatePetWithFormMutationKey();
+    return useSWRMutation<UpdatePetWithFormMutationResponse, UpdatePetWithForm405, UpdatePetWithFormMutationKey | null>(shouldFetch ? mutationKey : null, async (_url) => {
+        return updatePetWithForm({ petId }, params, config);
+    }, mutationOptions);
+}

package/src/generators/index.ts

@@ -0,0 +1,2 @@
+export { queryGenerator } from './queryGenerator.tsx'
+export { mutationGenerator } from './mutationGenerator.tsx'

package/src/generators/mutationGenerator.tsx

@@ -0,0 +1,117 @@
+import { pluginClientName } from '@kubb/plugin-client'
+import { Client } from '@kubb/plugin-client/components'
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { pluginZodName } from '@kubb/plugin-zod'
+import { File, useApp } from '@kubb/react'
+import { MutationKey } from '../components'
+import { Mutation } from '../components'
+import type { PluginSwr } from '../types'
+
+export const mutationGenerator = createReactGenerator<PluginSwr>({
+  name: 'swr-mutation',
+  Operation({ options, operation }) {
+    const {
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginSwr>()
+    const { getSchemas, getName, getFile } = useOperationManager()
+
+    const isQuery = typeof options.query === 'boolean' ? true : options.query?.methods.some((method) => operation.method === method)
+    const isMutation = !isQuery && options.mutation && options.mutation.methods.some((method) => operation.method === method)
+
+    const importPath = options.mutation ? options.mutation.importPath : 'swr'
+
+    const mutation = {
+      name: getName(operation, { type: 'function', prefix: 'use' }),
+      typeName: getName(operation, { type: 'type' }),
+      file: getFile(operation, { prefix: 'use' }),
+    }
+
+    const type = {
+      file: getFile(operation, { pluginKey: [pluginTsName] }),
+      //todo remove type?
+      schemas: getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' }),
+    }
+
+    const zod = {
+      file: getFile(operation, { pluginKey: [pluginZodName] }),
+      schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
+    }
+
+    const client = {
+      name: getName(operation, { type: 'function', pluginKey: [pluginClientName] }),
+    }
+
+    const mutationKey = {
+      name: getName(operation, { type: 'const', suffix: 'MutationKey' }),
+      typeName: getName(operation, { type: 'type', suffix: 'MutationKey' }),
+    }
+
+    if (!isMutation) {
+      return null
+    }
+
+    return (
+      <File baseName={mutation.file.baseName} path={mutation.file.path} meta={mutation.file.meta} banner={output?.banner} footer={output?.footer}>
+        {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={mutation.file.path} path={zod.file.path} />}
+        <File.Import name="useSWRMutation" path={importPath} />
+        <File.Import name={['SWRMutationResponse']} path={importPath} isTypeOnly />
+        <File.Import name={'client'} path={options.client.importPath} />
+        <File.Import name={['RequestConfig', 'ResponseConfig']} path={options.client.importPath} isTypeOnly />
+        <File.Import
+          name={[
+            type.schemas.request?.name,
+            type.schemas.response.name,
+            type.schemas.pathParams?.name,
+            type.schemas.queryParams?.name,
+            type.schemas.headerParams?.name,
+            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
+          ].filter(Boolean)}
+          root={mutation.file.path}
+          path={type.file.path}
+          isTypeOnly
+        />
+
+        <MutationKey
+          name={mutationKey.name}
+          typeName={mutationKey.typeName}
+          operation={operation}
+          pathParamsType={options.pathParamsType}
+          typeSchemas={type.schemas}
+          transformer={options.mutationKey}
+        />
+
+        <Client
+          name={client.name}
+          isExportable={false}
+          isIndexable={false}
+          baseURL={options.client.baseURL}
+          operation={operation}
+          typeSchemas={type.schemas}
+          zodSchemas={zod.schemas}
+          dataReturnType={options.client.dataReturnType}
+          paramsType={options.paramsType}
+          pathParamsType={options.pathParamsType}
+          parser={options.parser}
+        />
+        {options.mutation && (
+          <Mutation
+            name={mutation.name}
+            clientName={client.name}
+            typeName={mutation.typeName}
+            typeSchemas={type.schemas}
+            operation={operation}
+            dataReturnType={options.client.dataReturnType}
+            paramsType={options.paramsType}
+            pathParamsType={options.pathParamsType}
+            mutationKeyName={mutationKey.name}
+            mutationKeyTypeName={mutationKey.typeName}
+          />
+        )}
+      </File>
+    )
+  },
+})

package/src/generators/queryGenerator.tsx

@@ -0,0 +1,127 @@
+import { pluginClientName } from '@kubb/plugin-client'
+import { Client } from '@kubb/plugin-client/components'
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { pluginZodName } from '@kubb/plugin-zod'
+import { File, useApp } from '@kubb/react'
+import { Query, QueryOptions } from '../components'
+import { QueryKey } from '../components'
+import type { PluginSwr } from '../types'
+
+export const queryGenerator = createReactGenerator<PluginSwr>({
+  name: 'swr-query',
+  Operation({ options, operation }) {
+    const {
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginSwr>()
+    const { getSchemas, getName, getFile } = useOperationManager()
+
+    const isQuery = typeof options.query === 'boolean' ? options.query : !!options.query.methods?.some((method) => operation.method === method)
+    const importPath = options.query ? options.query.importPath : 'swr/mutation'
+
+    const query = {
+      name: getName(operation, { type: 'function', prefix: 'use' }),
+      typeName: getName(operation, { type: 'type' }),
+      file: getFile(operation, { prefix: 'use' }),
+    }
+
+    const client = {
+      name: getName(operation, { type: 'function', pluginKey: [pluginClientName] }),
+    }
+
+    const queryOptions = {
+      name: getName(operation, { type: 'function', suffix: 'QueryOptions' }),
+    }
+    const queryKey = {
+      name: getName(operation, { type: 'const', suffix: 'QueryKey' }),
+      typeName: getName(operation, { type: 'type', suffix: 'QueryKey' }),
+    }
+
+    const type = {
+      file: getFile(operation, { pluginKey: [pluginTsName] }),
+      //todo remove type?
+      schemas: getSchemas(operation, { pluginKey: [pluginTsName], type: 'type' }),
+    }
+
+    const zod = {
+      file: getFile(operation, { pluginKey: [pluginZodName] }),
+      schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
+    }
+
+    if (!isQuery) {
+      return null
+    }
+
+    return (
+      <File baseName={query.file.baseName} path={query.file.path} meta={query.file.meta} banner={output?.banner} footer={output?.footer}>
+        {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={query.file.path} path={zod.file.path} />}
+
+        <File.Import name={'client'} path={options.client.importPath} />
+        <File.Import name={['RequestConfig']} path={options.client.importPath} isTypeOnly />
+        {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
+
+        <File.Import
+          name={[
+            type.schemas.request?.name,
+            type.schemas.response.name,
+            type.schemas.pathParams?.name,
+            type.schemas.queryParams?.name,
+            type.schemas.headerParams?.name,
+            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
+          ].filter(Boolean)}
+          root={query.file.path}
+          path={type.file.path}
+          isTypeOnly
+        />
+        <QueryKey
+          name={queryKey.name}
+          typeName={queryKey.typeName}
+          operation={operation}
+          pathParamsType={options.pathParamsType}
+          typeSchemas={type.schemas}
+          transformer={options.queryKey}
+        />
+        <Client
+          name={client.name}
+          isExportable={false}
+          isIndexable={false}
+          baseURL={options.client.baseURL}
+          operation={operation}
+          typeSchemas={type.schemas}
+          zodSchemas={zod.schemas}
+          dataReturnType={options.client.dataReturnType}
+          paramsType={options.paramsType}
+          pathParamsType={options.pathParamsType}
+          parser={options.parser}
+        />
+        <QueryOptions
+          name={queryOptions.name}
+          clientName={client.name}
+          typeSchemas={type.schemas}
+          paramsType={options.paramsType}
+          pathParamsType={options.pathParamsType}
+        />
+        {options.query && (
+          <>
+            <File.Import name="useSWR" path={importPath} />
+            <File.Import name={['SWRResponse']} path={importPath} isTypeOnly />
+            <Query
+              name={query.name}
+              queryOptionsName={queryOptions.name}
+              typeSchemas={type.schemas}
+              paramsType={options.paramsType}
+              pathParamsType={options.pathParamsType}
+              operation={operation}
+              dataReturnType={options.client.dataReturnType}
+              queryKeyName={queryKey.name}
+              queryKeyTypeName={queryKey.typeName}
+            />
+          </>
+        )}
+      </File>
+    )
+  },
+})

package/src/index.ts

@@ -0,0 +1,4 @@
+import { pluginSwr } from './plugin.ts'
+
+export { pluginSwr, pluginSwrName } from './plugin.ts'
+export type { PluginSwr } from './types.ts'

package/src/plugin.ts

@@ -0,0 +1,141 @@
+import path from 'node:path'
+
+import { FileManager, type Group, PluginManager, createPlugin } from '@kubb/core'
+import { camelCase, pascalCase } from '@kubb/core/transformers'
+import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
+
+import { pluginTsName } from '@kubb/plugin-ts'
+import { pluginZodName } from '@kubb/plugin-zod'
+
+import type { Plugin } from '@kubb/core'
+import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
+import { MutationKey, QueryKey } from './components'
+import { mutationGenerator, queryGenerator } from './generators'
+import type { PluginSwr } from './types.ts'
+
+export const pluginSwrName = 'plugin-swr' satisfies PluginSwr['name']
+
+export const pluginSwr = createPlugin<PluginSwr>((options) => {
+  const {
+    output = { path: 'hooks', barrelType: 'named' },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    parser = 'client',
+    transformers = {},
+    query,
+    mutation,
+    client,
+    paramsType = 'inline',
+    pathParamsType = 'inline',
+    mutationKey = MutationKey.getTransformer,
+    queryKey = QueryKey.getTransformer,
+    generators = [queryGenerator, mutationGenerator].filter(Boolean),
+  } = options
+
+  return {
+    name: pluginSwrName,
+    options: {
+      output,
+      client: {
+        importPath: '@kubb/plugin-client/client',
+        dataReturnType: 'data',
+        ...client,
+      },
+      queryKey,
+      query: {
+        importPath: 'swr',
+        methods: ['get'],
+        ...query,
+      },
+      mutationKey,
+      mutation: {
+        importPath: 'swr/mutation',
+        methods: ['post', 'put', 'delete', 'patch'],
+        ...mutation,
+      },
+      parser,
+      paramsType,
+      pathParamsType: paramsType === 'object' ? 'object' : pathParamsType,
+    },
+    pre: [pluginOasName, pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
+    resolvePath(baseName, pathMode, options) {
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
+
+      if (options?.tag && group?.type === 'tag') {
+        const groupName: Group['name'] = group?.name ? group.name : (ctx) => `${ctx.group}Controller`
+
+        return path.resolve(root, output.path, groupName({ group: camelCase(options.tag) }), baseName)
+      }
+
+      if (mode === 'single') {
+        /**
+         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
+         */
+        return path.resolve(root, output.path)
+      }
+
+      return path.resolve(root, output.path, baseName)
+    },
+    resolveName(name, type) {
+      let resolvedName = camelCase(name)
+
+      if (type === 'file' || type === 'function') {
+        resolvedName = camelCase(name, {
+          isFile: type === 'file',
+        })
+      }
+
+      if (type === 'type') {
+        resolvedName = pascalCase(name)
+      }
+
+      if (type) {
+        return transformers?.name?.(resolvedName, type) || resolvedName
+      }
+
+      return resolvedName
+    },
+    async buildStart() {
+      const [swaggerPlugin]: [Plugin<SwaggerPluginOptions>] = PluginManager.getDependedPlugins<SwaggerPluginOptions>(this.plugins, [pluginOasName])
+
+      const oas = await swaggerPlugin.context.getOas()
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = FileManager.getMode(path.resolve(root, output.path))
+      const baseURL = await swaggerPlugin.context.getBaseURL()
+
+      if (baseURL) {
+        this.plugin.options.client.baseURL = baseURL
+      }
+      const operationGenerator = new OperationGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType: swaggerPlugin.context.contentType,
+        exclude,
+        include,
+        override,
+        mode,
+      })
+
+      const files = await operationGenerator.build(...generators)
+      await this.addFile(...files)
+
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
+        root,
+        output,
+        files: this.fileManager.files,
+        meta: {
+          pluginKey: this.plugin.key,
+        },
+        logger: this.logger,
+      })
+
+      await this.addFile(...barrelFiles)
+    },
+  }
+})