implement m6

Author: malcolm-kee

packages/openapi-ts/src/plugins/@faker-js/faker/api.ts

@@ -1,45 +1,49 @@
 import type { IR } from '@hey-api/shared';
 
-import type { $ } from '../../../ts-dsl';
-
-type Expression = ReturnType<typeof $.expr>;
+import type { Expression } from './shared/types';
+import type { FakerJsFakerPlugin } from './types';
+import { toNodeRefV1, toNodeV1 } from './v1/api';
 
 export type IApi = {
   /**
-   * Generate a Faker expression for a schema.
+   * Generate an inline Faker expression for a schema.
    *
    * Returns an expression that produces a valid instance when executed.
-   * Use when you need one-off generation without referencing shared artifacts.
+   * The returned expression may reference faker symbols (`ensureFaker`,
+   * `options`) — cross-plugin references resolve imports automatically.
    *
    * @example
    * ```ts
+   * // For { type: 'object', properties: { name: string, email: string } }:
    * {
-   *   name: faker.person.fullName(),
-   *   email: faker.internet.email()
+   *   name: ensureFaker(options).person.fullName(),
+   *   email: ensureFaker(options).internet.email()
    * }
    * ```
    */
-  toNode(schema: IR.SchemaObject): Expression;
+  toNode(args: { plugin: FakerJsFakerPlugin['Instance']; schema: IR.SchemaObject }): Expression;
   /**
-   * Get a reference to a generated Faker expression for a schema.
+   * Get a reference to an existing Faker factory for a schema.
    *
-   * Returns a call expression referencing the shared artifact.
-   * If the artifact doesn't exist, it will be created.
+   * For `$ref` schemas, looks up the registered factory symbol via
+   * `referenceSymbol` and returns a call expression (e.g. `fakeUser(options)`).
+   * For non-`$ref` schemas, falls back to an inline expression via `toNode`.
    *
    * @example
-   * // Returns: fakeUser()
+   * ```ts
+   * // For { $ref: '#/components/schemas/User' }:
+   * fakeUser(options)
+   * ```
    */
-  toNodeRef(schema: IR.SchemaObject): Expression;
+  toNodeRef(args: { plugin: FakerJsFakerPlugin['Instance']; schema: IR.SchemaObject }): Expression;
 };
 
 export class Api implements IApi {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  toNode(_schema: IR.SchemaObject): Expression {
-    return undefined as any;
+  toNode(args: { plugin: FakerJsFakerPlugin['Instance']; schema: IR.SchemaObject }): Expression {
+    return toNodeV1(args);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  toNodeRef(_schema: IR.SchemaObject): Expression {
-    return undefined as any;
+  toNodeRef(args: { plugin: FakerJsFakerPlugin['Instance']; schema: IR.SchemaObject }): Expression {
+    return toNodeRefV1(args);
   }
 }

packages/openapi-ts/src/plugins/@faker-js/faker/shared/operation.ts

@@ -112,7 +112,8 @@ function exportOperationResponse({
         path: [...path, group, statusCode],
         resource: 'operation',
         resourceId: operation.id,
-        role: group,
+        role: 'response',
+        statusCode,
         tags,
         tool: 'faker',
       },
@@ -125,12 +126,11 @@ function exportOperationResponse({
 
   // Look up TypeScript type for indexed access return type
   // 2XX codes → responses (plural), 4XX/5XX → errors (plural)
-  const typeRole = group; // 'responses' or 'errors'
   const typeSymbol = plugin.querySymbol({
     category: 'type',
     resource: 'operation',
     resourceId: operation.id,
-    role: typeRole,
+    role: group,
     tool: 'typescript',
   });
 
@@ -148,6 +148,85 @@ function exportOperationResponse({
   plugin.node($.const(symbol).export().assign(arrowFn));
 }
 
+/**
+ * Export an unsuffixed operation response factory (single meaningful 2XX, no errors).
+ * Uses manual export with consistent metadata (role: 'response', statusCode).
+ */
+function exportUnsuffixedResponse({
+  naming,
+  operation,
+  path,
+  plugin,
+  processor,
+  schema,
+  statusCode,
+  tags,
+}: {
+  naming: NamingConfig;
+  operation: IR.OperationObject;
+  path: ReadonlyArray<string | number>;
+  plugin: FakerJsFakerPlugin['Instance'];
+  processor: ProcessorResult;
+  schema: IR.SchemaObject;
+  statusCode: string;
+  tags?: ReadonlyArray<string>;
+}): void {
+  const result = processor.process({
+    export: false,
+    meta: {
+      resource: 'operation',
+      resourceId: operation.id,
+      role: 'response',
+    },
+    naming,
+    namingAnchor: operation.id,
+    path: [...path, 'responses'],
+    plugin,
+    schema,
+    tags,
+  }) as FakerResult | void;
+
+  if (!result) return;
+
+  const name = pathToName([...path, 'responses'], { anchor: operation.id });
+
+  const symbol = plugin.registerSymbol(
+    buildSymbolIn({
+      meta: {
+        category: 'schema',
+        path: [...path, 'responses'],
+        resource: 'operation',
+        resourceId: operation.id,
+        role: 'response',
+        statusCode,
+        tags,
+        tool: 'faker',
+      },
+      name,
+      naming,
+      plugin,
+      schema,
+    }),
+  );
+
+  // Look up TypeScript type (singular 'response' role)
+  const typeSymbol = plugin.querySymbol({
+    category: 'type',
+    resource: 'operation',
+    resourceId: operation.id,
+    role: 'response',
+    tool: 'typescript',
+  });
+
+  const arrowFn = $.func()
+    .arrow()
+    .$if(result.usesFaker, (f) => f.param('options', (p) => p.optional().type('Options')))
+    .$if(typeSymbol, (f) => f.returns($.type(typeSymbol!)))
+    .do($.return(result.expression));
+
+  plugin.node($.const(symbol).export().assign(arrowFn));
+}
+
 export function irOperationToAst({
   operation,
   path,
@@ -172,23 +251,18 @@ export function irOperationToAst({
   const useSuffix = !(meaningful.length === 1 && meaningful[0]!.group === 'responses');
 
   if (!useSuffix) {
-    // Single 2XX: no suffix, use standard exportAst pipeline
     const entry = meaningful[0]!;
-    processor.process({
-      meta: {
-        resource: 'operation',
-        resourceId: operation.id,
-        role: 'response',
-      },
+    exportUnsuffixedResponse({
       naming: plugin.config.responses,
-      namingAnchor: operation.id,
-      path: [...path, 'responses'],
+      operation,
+      path,
       plugin,
+      processor,
       schema: entry.schema,
+      statusCode: entry.statusCode,
       tags,
     });
   } else {
-    // Suffixed: per-status-code factories
     for (const entry of meaningful) {
       exportOperationResponse({
         group: entry.group,

packages/openapi-ts/src/plugins/@faker-js/faker/v1/api.ts

@@ -0,0 +1,42 @@
+import { ref } from '@hey-api/codegen-core';
+import type { IR } from '@hey-api/shared';
+import { createSchemaWalker } from '@hey-api/shared';
+
+import { $ } from '../../../../ts-dsl';
+import type { EmitTracking, Expression, FakerResult } from '../shared/types';
+import type { FakerJsFakerPlugin } from '../types';
+import { createVisitor } from './walker';
+
+export function toNodeV1({
+  plugin,
+  schema,
+}: {
+  plugin: FakerJsFakerPlugin['Instance'];
+  schema: IR.SchemaObject;
+}): Expression {
+  const tracking: EmitTracking = { needsResolveCondition: false };
+  const visitor = createVisitor({ plugin, tracking });
+  const walk = createSchemaWalker(visitor);
+  const result = walk(schema, { path: ref([]), plugin });
+  const final = visitor.applyModifiers(result, { path: ref([]), plugin }) as FakerResult;
+  return final.expression;
+}
+
+export function toNodeRefV1({
+  plugin,
+  schema,
+}: {
+  plugin: FakerJsFakerPlugin['Instance'];
+  schema: IR.SchemaObject;
+}): Expression {
+  if (schema.$ref) {
+    const symbol = plugin.referenceSymbol({
+      category: 'schema',
+      resource: 'definition',
+      resourceId: schema.$ref,
+      tool: 'faker',
+    });
+    return $(symbol).call($('options'));
+  }
+  return toNodeV1({ plugin, schema });
+}