@kubb/plugin-zod 5.0.0-alpha.24 → 5.0.0-alpha.26

package/src/generators/zodGeneratorLegacy.tsx

@@ -0,0 +1,401 @@
+import path from 'node:path'
+import { caseParams, composeTransformers, createProperty, createSchema, transform } from '@kubb/ast'
+import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
+import { defineGenerator, getMode } from '@kubb/core'
+import { File } from '@kubb/react-fabric'
+import { Operations } from '../components/Operations.tsx'
+import { Zod } from '../components/Zod.tsx'
+import { ZodMini } from '../components/ZodMini.tsx'
+import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
+import type { PluginZod, ResolverZod } from '../types'
+
+type BuildGroupedParamsSchemaOptions = {
+  params: Array<ParameterNode>
+}
+
+function buildGroupedParamsSchema({ params, optional }: BuildGroupedParamsSchemaOptions & { optional?: boolean }): SchemaNode {
+  return createSchema({
+    type: 'object',
+    optional,
+    primitive: 'object',
+    properties: params.map((param) => {
+      return createProperty({
+        name: param.name,
+        required: param.required,
+        schema: param.schema,
+      })
+    }),
+  })
+}
+
+type BuildOperationSchemaOptions = {
+  resolver: ResolverZod
+}
+
+function buildLegacyResponsesSchemaNode(node: OperationNode, { resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+  const isGet = node.method.toLowerCase() === 'get'
+  const successResponses = node.responses.filter((res) => {
+    const code = Number(res.statusCode)
+    return !Number.isNaN(code) && code >= 200 && code < 300
+  })
+  const errorResponses = node.responses.filter((res) => res.statusCode === 'default' || Number(res.statusCode) >= 400)
+
+  const responseSchema =
+    successResponses.length > 0
+      ? successResponses.length === 1
+        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
+        : createSchema({
+            type: 'union',
+            members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+          })
+      : createSchema({ type: 'any' })
+
+  const errorsSchema =
+    errorResponses.length > 0
+      ? errorResponses.length === 1
+        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, errorResponses[0]!.statusCode) })
+        : createSchema({
+            type: 'union',
+            members: errorResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+          })
+      : createSchema({ type: 'any' })
+
+  const properties = [createProperty({ name: 'Response', required: true, schema: responseSchema })]
+
+  if (!isGet && node.requestBody?.schema) {
+    properties.push(
+      createProperty({
+        name: 'Request',
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveDataName(node) }),
+      }),
+    )
+  }
+
+  const queryParam = node.parameters.find((p) => p.in === 'query')
+  if (queryParam) {
+    properties.push(
+      createProperty({
+        name: 'QueryParams',
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsName(node, queryParam) }),
+      }),
+    )
+  }
+
+  const pathParam = node.parameters.find((p) => p.in === 'path')
+  if (pathParam) {
+    properties.push(
+      createProperty({
+        name: 'PathParams',
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolvePathParamsName(node, pathParam) }),
+      }),
+    )
+  }
+
+  const headerParam = node.parameters.find((p) => p.in === 'header')
+  if (headerParam) {
+    properties.push(
+      createProperty({
+        name: 'HeaderParams',
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveHeaderParamsName(node, headerParam) }),
+      }),
+    )
+  }
+
+  properties.push(createProperty({ name: 'Errors', required: true, schema: errorsSchema }))
+
+  return createSchema({ type: 'object', primitive: 'object', properties })
+}
+
+function buildLegacyResponseUnionSchemaNode(node: OperationNode, { resolver }: BuildOperationSchemaOptions): SchemaNode {
+  const successResponses = node.responses.filter((res) => {
+    const code = Number(res.statusCode)
+    return !Number.isNaN(code) && code >= 200 && code < 300
+  })
+
+  if (successResponses.length === 0) {
+    return createSchema({ type: 'any' })
+  }
+
+  if (successResponses.length === 1) {
+    return createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
+  }
+
+  return createSchema({
+    type: 'union',
+    members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
+  })
+}
+
+function buildLegacySchemaNames(node: OperationNode, params: Array<ParameterNode>, resolver: ResolverZod) {
+  const pathParam = params.find((p) => p.in === 'path')
+  const queryParam = params.find((p) => p.in === 'query')
+  const headerParam = params.find((p) => p.in === 'header')
+
+  const responses: Record<number | string, string> = {}
+  const errors: Record<number | string, string> = {}
+
+  for (const res of node.responses) {
+    const name = resolver.resolveResponseStatusName(node, res.statusCode)
+    const statusNum = Number(res.statusCode)
+
+    if (!Number.isNaN(statusNum)) {
+      responses[statusNum] = name
+      if (statusNum >= 400) {
+        errors[statusNum] = name
+      }
+    }
+  }
+
+  responses['default'] = resolver.resolveResponseName(node)
+
+  return {
+    request: node.requestBody?.schema ? resolver.resolveDataName(node) : undefined,
+    parameters: {
+      path: pathParam ? resolver.resolvePathParamsName(node, pathParam) : undefined,
+      query: queryParam ? resolver.resolveQueryParamsName(node, queryParam) : undefined,
+      header: headerParam ? resolver.resolveHeaderParamsName(node, headerParam) : undefined,
+    },
+    responses,
+    errors,
+  }
+}
+
+export const zodGeneratorLegacy = defineGenerator<PluginZod>({
+  name: 'zod-legacy',
+  type: 'react',
+  Schema({ node, adapter, options, config, resolver }) {
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, transformers = [] } = options
+    const transformedNode = transform(node, composeTransformers(...transformers))
+
+    if (!transformedNode.name) {
+      return
+    }
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
+    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
+
+    const imports = adapter.getImports(transformedNode, (schemaName) => ({
+      name: resolver.default(schemaName, 'function'),
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+    }))
+
+    const inferTypeName = inferred ? resolver.resolveInferName(resolver.resolveName(transformedNode.name)) : undefined
+
+    const meta = {
+      name: resolver.default(transformedNode.name, 'function'),
+      file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
+    } as const
+
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
+        <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
+        {mode === 'split' &&
+          imports.map((imp) => <File.Import key={[transformedNode.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+
+        {mini ? (
+          <ZodMini name={meta.name} node={transformedNode} guidType={guidType} wrapOutput={wrapOutput} inferTypeName={inferTypeName} resolver={resolver} />
+        ) : (
+          <Zod
+            name={meta.name}
+            node={transformedNode}
+            coercion={coercion}
+            guidType={guidType}
+            wrapOutput={wrapOutput}
+            inferTypeName={inferTypeName}
+            resolver={resolver}
+          />
+        )}
+      </File>
+    )
+  },
+  Operation({ node, adapter, options, config, resolver }) {
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, transformers } = options
+
+    const transformedNode = transform(node, composeTransformers(...transformers))
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
+    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
+
+    const params = caseParams(transformedNode.parameters, paramsCasing)
+
+    const meta = {
+      file: resolver.resolveFile(
+        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+        { root, output, group },
+      ),
+    } as const
+
+    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+      if (!schema) return null
+
+      const inferTypeName = inferred ? resolver.resolveInferName(name) : undefined
+
+      const imports = adapter.getImports(schema, (schemaName) => ({
+        name: resolver.default(schemaName, 'function'),
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      }))
+
+      return (
+        <>
+          {mode === 'split' &&
+            imports.map((imp) => <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+          {mini ? (
+            <ZodMini
+              name={name}
+              node={schema}
+              guidType={guidType}
+              wrapOutput={wrapOutput}
+              inferTypeName={inferTypeName}
+              resolver={resolver}
+              keysToOmit={keysToOmit}
+            />
+          ) : (
+            <Zod
+              name={name}
+              node={schema}
+              coercion={coercion}
+              guidType={guidType}
+              wrapOutput={wrapOutput}
+              inferTypeName={inferTypeName}
+              resolver={resolver}
+              keysToOmit={keysToOmit}
+            />
+          )}
+        </>
+      )
+    }
+
+    const pathParams = params.filter((p) => p.in === 'path')
+    const queryParams = params.filter((p) => p.in === 'query')
+    const headerParams = params.filter((p) => p.in === 'header')
+
+    const responseSchemas = transformedNode.responses.map((res) => {
+      const responseName = resolver.resolveResponseStatusName(transformedNode, res.statusCode)
+      return renderSchemaEntry({
+        schema: {
+          ...res.schema,
+          description: res.description ?? res.schema.description,
+        },
+        name: responseName,
+        keysToOmit: res.keysToOmit,
+      })
+    })
+
+    const requestSchema = transformedNode.requestBody?.schema
+      ? renderSchemaEntry({
+          schema: {
+            ...transformedNode.requestBody.schema,
+            description: transformedNode.requestBody.description ?? transformedNode.requestBody.schema.description,
+          },
+          name: resolver.resolveDataName(transformedNode),
+          keysToOmit: transformedNode.requestBody.keysToOmit,
+        })
+      : null
+
+    const legacyParamTypes = [
+      pathParams.length > 0
+        ? renderSchemaEntry({
+            schema: buildGroupedParamsSchema({ params: pathParams, optional: pathParams.every((p) => !p.required) }),
+            name: resolver.resolvePathParamsName(transformedNode, pathParams[0]!),
+          })
+        : null,
+      queryParams.length > 0
+        ? renderSchemaEntry({
+            schema: buildGroupedParamsSchema({ params: queryParams, optional: queryParams.every((p) => !p.required) }),
+            name: resolver.resolveQueryParamsName(transformedNode, queryParams[0]!),
+          })
+        : null,
+      headerParams.length > 0
+        ? renderSchemaEntry({
+            schema: buildGroupedParamsSchema({ params: headerParams, optional: headerParams.every((p) => !p.required) }),
+            name: resolver.resolveHeaderParamsName(transformedNode, headerParams[0]!),
+          })
+        : null,
+    ]
+
+    const legacyResponsesSchema = renderSchemaEntry({
+      schema: buildLegacyResponsesSchemaNode(transformedNode, { resolver }),
+      name: resolver.resolveResponsesName(transformedNode),
+    })
+
+    const legacyResponseSchema = renderSchemaEntry({
+      schema: buildLegacyResponseUnionSchemaNode(transformedNode, { resolver }),
+      name: resolver.resolveResponseName(transformedNode),
+    })
+
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
+        <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
+        {legacyParamTypes}
+        {responseSchemas}
+        {requestSchema}
+        {legacyResponseSchema}
+        {legacyResponsesSchema}
+      </File>
+    )
+  },
+  Operations({ nodes, adapter, options, config, resolver }) {
+    const { output, importPath, group, operations, paramsCasing, transformers } = options
+
+    if (!operations) {
+      return
+    }
+
+    const root = path.resolve(config.root, config.output.path)
+    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
+
+    const meta = {
+      file: resolver.resolveFile({ name: 'operations', extname: '.ts' }, { root, output, group }),
+    } as const
+
+    const transformedOperations = nodes.map((node) => {
+      const transformedNode = transform(node, composeTransformers(...transformers))
+
+      const params = caseParams(transformedNode.parameters, paramsCasing)
+
+      return {
+        node: transformedNode,
+        data: buildLegacySchemaNames(transformedNode, params, resolver),
+      }
+    })
+
+    const imports = transformedOperations.flatMap(({ node, data }) => {
+      const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean) as string[]
+      const opFile = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
+
+      return names.map((name) => <File.Import key={[name, opFile.path].join('-')} name={[name]} root={meta.file.path} path={opFile.path} />)
+    })
+
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
+        <File.Import isTypeOnly name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
+        {imports}
+        <Operations name="operations" operations={transformedOperations} />
+      </File>
+    )
+  },
+})

package/src/index.ts

@@ -1,2 +1,12 @@
+export { zodGenerator } from './generators/zodGenerator.tsx'
+export { zodGeneratorLegacy } from './generators/zodGeneratorLegacy.tsx'
+
 export { pluginZod, pluginZodName } from './plugin.ts'
-export type { PluginZod } from './types.ts'
+
+export { printerZod } from './printers/printerZod.ts'
+export { printerZodMini } from './printers/printerZodMini.ts'
+
+export { resolverZod } from './resolvers/resolverZod.ts'
+export { resolverZodLegacy } from './resolvers/resolverZodLegacy.ts'
+
+export type { PluginZod, ResolverZod } from './types.ts'

package/src/plugin.ts

@@ -1,15 +1,32 @@
 import path from 'node:path'
-import { camelCase, pascalCase } from '@internals/utils'
-import { createPlugin, getBarrelFiles, getMode, satisfiesDependency, type UserGroup } from '@kubb/core'
-import { OperationGenerator, pluginOasName, SchemaGenerator } from '@kubb/plugin-oas'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { operationsGenerator } from './generators'
-import { zodGenerator } from './generators/zodGenerator.tsx'
-import { source as toZodSource } from './templates/ToZod.source.ts'
+import { camelCase } from '@internals/utils'
+import { walk } from '@kubb/ast'
+import type { OperationNode } from '@kubb/ast/types'
+import { createPlugin, type Group, getBarrelFiles, getPreset, runGeneratorOperation, runGeneratorOperations, runGeneratorSchema } from '@kubb/core'
+import { presets } from './presets.ts'
 import type { PluginZod } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-zod`, used to identify the plugin in driver lookups and warnings.
+ */
 export const pluginZodName = 'plugin-zod' satisfies PluginZod['name']
 
+/**
+ * The `@kubb/plugin-zod` plugin factory.
+ *
+ * Generates Zod validation schemas from an OpenAPI/AST `RootNode`.
+ * Walks schemas and operations, delegates rendering to the active generators,
+ * and writes barrel files based on `output.barrelType`.
+ *
+ * @example
+ * ```ts
+ * import { pluginZod } from '@kubb/plugin-zod'
+ *
+ * export default defineConfig({
+ *   plugins: [pluginZod({ output: { path: 'zod' } })],
+ * })
+ * ```
+ */
 export const pluginZod = createPlugin<PluginZod>((options) => {
   const {
     output = { path: 'zod', barrelType: 'named' },
@@ -17,156 +34,115 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     exclude = [],
     include,
     override = [],
-    transformers = {},
     dateType = 'string',
-    unknownType = 'any',
-    emptySchemaType = unknownType,
-    integerType = 'number',
     typed = false,
-    mapper = {},
     operations = false,
     mini = false,
-    version = mini ? '4' : satisfiesDependency('zod', '>=4') ? '4' : '3',
     guidType = 'uuid',
-    importPath = mini ? 'zod/mini' : version === '4' ? 'zod/v4' : 'zod',
+    importPath = mini ? 'zod/mini' : 'zod',
     coercion = false,
     inferred = false,
-    generators = [zodGenerator, operations ? operationsGenerator : undefined].filter(Boolean),
     wrapOutput = undefined,
-    contentType,
+    paramsCasing,
+    compatibilityPreset = 'default',
+    resolvers: userResolvers = [],
+    transformers: userTransformers = [],
+    generators: userGenerators = [],
   } = options
 
-  // @deprecated Will be removed in v5 when collisionDetection defaults to true
-  const usedEnumNames = {}
+  const preset = getPreset({
+    preset: compatibilityPreset,
+    presets: presets,
+    resolvers: userResolvers,
+    transformers: userTransformers,
+    generators: userGenerators,
+  })
+
+  let resolveNameWarning = false
+  let resolvePathWarning = false
 
   return {
     name: pluginZodName,
-    options: {
-      output,
-      transformers,
-      include,
-      exclude,
-      override,
-      typed,
-      dateType,
-      unknownType,
-      emptySchemaType,
-      integerType,
-      mapper,
-      importPath,
-      coercion,
-      operations,
-      inferred,
-      group,
-      wrapOutput,
-      version,
-      guidType,
-      mini,
-      usedEnumNames,
+    get resolver() {
+      return preset.resolver
     },
-    pre: [pluginOasName, typed ? pluginTsName : undefined].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? getMode(path.resolve(root, output.path))
-
-      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)
+    get options() {
+      return {
+        output,
+        group: group
+          ? ({
+              ...group,
+              name: (ctx) => {
+                if (group.type === 'path') {
+                  return `${ctx.group.split('/')[1]}`
+                }
+                return `${camelCase(ctx.group)}Controller`
+              },
+            } satisfies Group)
+          : undefined,
+        dateType,
+        typed,
+        importPath,
+        coercion,
+        operations,
+        inferred,
+        guidType,
+        mini,
+        wrapOutput,
+        paramsCasing,
+        transformers: preset.transformers,
       }
-
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: UserGroup['name'] = group?.name
-          ? group.name
-          : (ctx) => {
-              if (group?.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-              return `${camelCase(ctx.group)}Controller`
-            }
-
-        return path.resolve(
-          root,
-          output.path,
-          groupName({
-            group: group.type === 'path' ? options.group.path! : options.group.tag!,
-          }),
-          baseName,
-        )
+    },
+    resolvePath(baseName, pathMode, options) {
+      if (!resolvePathWarning) {
+        this.events.emit('warn', 'Do not use resolvePath for pluginZod, use resolverZod.resolvePath instead')
+        resolvePathWarning = true
       }
 
-      return path.resolve(root, output.path, baseName)
+      return this.plugin.resolver.resolvePath(
+        { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
+        { root: path.resolve(this.config.root, this.config.output.path), output, group: this.plugin.options.group },
+      )
     },
     resolveName(name, type) {
-      let resolvedName = camelCase(name, {
-        suffix: type ? 'schema' : undefined,
-        isFile: type === 'file',
-      })
-
-      if (type === 'type') {
-        resolvedName = pascalCase(resolvedName)
-      }
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
+      if (!resolveNameWarning) {
+        this.events.emit('warn', 'Do not use resolveName for pluginZod, use resolverZod.default instead')
+        resolveNameWarning = true
       }
 
-      return resolvedName
+      return this.plugin.resolver.default(name, type)
     },
     async install() {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = getMode(path.resolve(root, output.path))
-      const oas = await this.getOas()
-
-      if (this.plugin.options.typed && this.plugin.options.version === '3') {
-        // pre add bundled
-        await this.addFile({
-          baseName: 'ToZod.ts',
-          path: path.resolve(root, '.kubb/ToZod.ts'),
-          sources: [
-            {
-              name: 'ToZod',
-              value: toZodSource,
-            },
-          ],
-          imports: [],
-          exports: [],
-        })
+      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this
+
+      const root = path.resolve(config.root, config.output.path)
+
+      if (!adapter) {
+        throw new Error(`[${pluginZodName}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`)
       }
 
-      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        include: undefined,
-        override,
-        mode,
-        output: output.path,
-      })
+      await openInStudio({ ast: true })
+
+      const collectedOperations: Array<OperationNode> = []
+      const generatorContext = { generators: preset.generators, plugin, resolver, exclude, include, override, fabric, adapter, config, driver }
 
-      const schemaFiles = await schemaGenerator.build(...generators)
-      await this.upsertFile(...schemaFiles)
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
+      await walk(rootNode, {
+        depth: 'shallow',
+        async schema(schemaNode) {
+          await runGeneratorSchema(schemaNode, generatorContext)
+        },
+        async operation(operationNode) {
+          const baseOptions = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
+
+          if (baseOptions !== null) {
+            collectedOperations.push(operationNode)
+          }
+
+          await runGeneratorOperation(operationNode, generatorContext)
+        },
       })
 
-      const operationFiles = await operationGenerator.build(...generators)
-      await this.upsertFile(...operationFiles)
+      await runGeneratorOperations(collectedOperations, generatorContext)
 
       const barrelFiles = await getBarrelFiles(this.fabric.files, {
         type: output.barrelType ?? 'named',