@pattern-stack/codegen 0.3.2 → 0.4.0

package/dist/src/cli/index.js

@@ -218304,6 +218304,7 @@ async function detectInstalledSubsystems(ctx) {
     if (!fs8.existsSync(root)) continue;
     for (const name of KNOWN_NAMES) {
       if (seen.has(name)) continue;
+      if (name === "openapi-config") continue;
       const dir = path16.join(root, name);
       if (!fs8.existsSync(dir) || !fs8.statSync(dir).isDirectory()) continue;
       const files = fs8.readdirSync(dir);
@@ -218317,6 +218318,25 @@ async function detectInstalledSubsystems(ctx) {
       });
     }
   }
+  if (!seen.has("openapi-config")) {
+    const configPath = path16.resolve(
+      ctx.cwd,
+      ctx.config ? "codegen.config.yaml" : "codegen.config.yaml"
+    );
+    if (fs8.existsSync(configPath)) {
+      try {
+        const source = fs8.readFileSync(configPath, "utf-8");
+        if (/^openapi\s*:/m.test(source)) {
+          found.push({
+            name: "openapi-config",
+            path: configPath,
+            backend: "config-only"
+          });
+        }
+      } catch {
+      }
+    }
+  }
   return found;
 }
 var SUBSYSTEMS, KNOWN_NAMES;
@@ -218359,6 +218379,16 @@ var init_subsystem_detect = __esm({
         description: "Event-to-job bridge (durable async fanout via @JobHandler.triggers)",
         backends: ["drizzle", "memory"],
         defaultBackend: "drizzle"
+      },
+      {
+        // OPENAPI-4. "Config-only" pseudo-subsystem — the runtime helpers
+        // (OpenApiRegistry, ErrorResponseDto) are already vendored by
+        // `codegen project init`. Installing this subsystem just injects the
+        // `openapi:` block into codegen.config.yaml.
+        name: "openapi-config",
+        description: "OpenAPI/Swagger config block (registry is vendored at init)",
+        backends: ["config-only"],
+        defaultBackend: "config-only"
       }
     ];
     KNOWN_NAMES = SUBSYSTEMS.map((s) => s.name);
@@ -218830,6 +218860,9 @@ var init_subsystem = __esm({
           );
           return 2;
         }
+        if (desc.name === "openapi-config") {
+          return this.executeOpenApiConfig(ctx);
+        }
         const installed = await detectInstalledSubsystems(ctx);
         const already = installed.find((i) => i.name === desc.name);
         if (already && !this.force) {
@@ -219041,6 +219074,72 @@ var init_subsystem = __esm({
         }
         return 0;
       }
+      /**
+       * OPENAPI-4: install flow for the config-only `openapi-config`
+       * pseudo-subsystem.
+       *
+       * Nothing to copy — `src/shared/openapi/*` was already vendored by
+       * `codegen project init`. This method just invokes the
+       * `subsystem/openapi-config` Hygen action to inject the `openapi:`
+       * block into `codegen.config.yaml`, honoring the same `--force-config`
+       * semantics as jobs/events/sync/bridge.
+       */
+      async executeOpenApiConfig(ctx) {
+        const configPath = path17.join(ctx.cwd, "codegen.config.yaml");
+        const outcome = planConfigBlockAction(configPath, "openapi", this.forceConfig);
+        if (outcome === "parse-error") {
+          printError(
+            "codegen.config.yaml is not valid YAML: refusing to inject openapi config block. Fix the YAML and re-run."
+          );
+          return 1;
+        }
+        if (this.dryRun) {
+          if (isJsonMode()) {
+            printJson({
+              command: "subsystem install",
+              subsystem: "openapi-config",
+              dryRun: true,
+              configBlockOutcome: outcome,
+              planned: [configPath]
+            });
+          } else {
+            printInfo(`Dry run \u2014 openapi config block would be ${outcome}`);
+            console.log(`  ${theme.muted(icons.arrow)} ${path17.relative(ctx.cwd, configPath) || configPath}`);
+          }
+          return 0;
+        }
+        const configResult = runConfigBlockAction({
+          cwd: ctx.cwd,
+          actionFolder: "openapi-config",
+          configPath,
+          subsystem: "openapi",
+          outcome,
+          json: isJsonMode()
+        });
+        if (!configResult.ok) {
+          printError(
+            `openapi-config install failed: ${configResult.error ?? "unknown error"}`
+          );
+          return 1;
+        }
+        if (isJsonMode()) {
+          printJson({
+            command: "subsystem install",
+            subsystem: "openapi-config",
+            configBlockOutcome: outcome,
+            configPath
+          });
+          return 0;
+        }
+        printSuccess(`openapi config block ${outcome === "skipped" ? "already present" : "installed"}.`);
+        printInfo(
+          "Install the peer deps: bun add @nestjs/swagger @anatine/zod-openapi"
+        );
+        printInfo(
+          "Swagger UI mounts at /docs once main.ts calls SwaggerModule.setup(...) \u2014 see CONSUMER-SETUP.md \xA7OpenAPI."
+        );
+        return 0;
+      }
     };
     SubsystemListCommand = class extends Command3 {
       static paths = [["subsystem", "list"]];
@@ -219179,22 +219278,158 @@ export class DatabaseModule {}
 `;
 }
 function appModuleContent() {
-  return `import { Module } from '@nestjs/common';
+  return `import { Global, Module } from '@nestjs/common';
 import { DatabaseModule } from './shared/database/database.module';
 import { GENERATED_MODULES } from './generated/modules';
+import { OPENAPI_REGISTRY, OpenApiRegistry } from './shared/openapi';
 
 /**
- * AppModule \u2014 wires DatabaseModule (global) + the GENERATED_MODULES barrel.
+ * OpenApiModule \u2014 @Global() wrapper around the OPENAPI_REGISTRY singleton.
+ *
+ * OPENAPI-4: every generated entity module \`@Inject(OPENAPI_REGISTRY)\` to
+ * register its Zod DTOs at onModuleInit (OPENAPI-2). NestJS's DI scoping
+ * means providers declared in AppModule are NOT automatically visible
+ * inside imported feature modules \u2014 exports from AppModule only flow to
+ * modules that explicitly import AppModule, which feature modules don't.
+ * Making the provider module \`@Global()\` broadcasts the token to every
+ * module in the application graph; each generated module picks it up
+ * without needing to import anything extra.
+ *
+ * \`useValue: new OpenApiRegistry()\` locks the instance to one per
+ * process. Never instantiate \`new OpenApiRegistry()\` elsewhere \u2014 a
+ * forked registry forks the schema table and produces a partial
+ * /docs-json at boot.
+ */
+@Global()
+@Module({
+  providers: [{ provide: OPENAPI_REGISTRY, useValue: new OpenApiRegistry() }],
+  exports: [OPENAPI_REGISTRY],
+})
+class OpenApiModule {}
+
+/**
+ * AppModule \u2014 wires DatabaseModule (global) + the OpenApiModule (global)
+ * + the GENERATED_MODULES barrel.
  *
  * DatabaseModule must come first \u2014 it provides the DRIZZLE token that every
- * generated repository depends on.
+ * generated repository depends on. OpenApiModule follows so the registry
+ * is in the global injector before any generated module's onModuleInit
+ * fires. main.ts reads the built registry at boot to produce the Swagger
+ * document (OPENAPI-4).
  */
 @Module({
-  imports: [DatabaseModule, ...GENERATED_MODULES],
+  imports: [DatabaseModule, OpenApiModule, ...GENERATED_MODULES],
 })
 export class AppModule {}
 `;
 }
+function mainTsContent() {
+  return `import 'reflect-metadata';
+import fs from 'node:fs';
+import path from 'node:path';
+import { NestFactory } from '@nestjs/core';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { parse as parseYaml } from 'yaml';
+import { AppModule } from './app.module';
+import { OPENAPI_REGISTRY, OpenApiRegistry } from './shared/openapi';
+
+interface OpenApiConfig {
+  enabled?: boolean;
+  path?: string;
+  title?: string;
+  version?: string;
+  description?: string;
+  auth?: 'bearer' | 'none';
+}
+
+interface CodegenConfig {
+  openapi?: OpenApiConfig;
+}
+
+/**
+ * Load \`codegen.config.yaml\` to pick up the \`openapi:\` block. Missing or
+ * malformed \u2192 no config (Swagger disabled). The registry is the source of
+ * truth for the document content; this just toggles whether Swagger UI
+ * mounts + which metadata the header shows.
+ */
+function loadConfig(): CodegenConfig {
+  const configPath = path.resolve(process.cwd(), 'codegen.config.yaml');
+  if (!fs.existsSync(configPath)) return {};
+  try {
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    const parsed = parseYaml(raw);
+    return (parsed && typeof parsed === 'object' ? parsed : {}) as CodegenConfig;
+  } catch {
+    return {};
+  }
+}
+
+async function bootstrap(): Promise<void> {
+  const config = loadConfig();
+  const app = await NestFactory.create(AppModule);
+  app.enableShutdownHooks();
+
+  if (config.openapi?.enabled) {
+    // OPENAPI-4: build the document in two passes.
+    //
+    //   1. Our vendored \`OpenApiRegistry\` owns the component schemas
+    //      (Zod-derived DTOs registered by every generated module at
+    //      onModuleInit \u2014 OPENAPI-2).
+    //   2. \`SwaggerModule.createDocument\` scans controller decorators
+    //      (@Api* \u2014 OPENAPI-3) and produces the \`paths\` map. Our
+    //      schemas then get merged into the \`components.schemas\` it
+    //      emits by reference.
+    //
+    // Both passes are needed: Nest's scanner is the source of truth for
+    // paths (it knows the routes); the registry is the source of truth
+    // for schemas (Zod can't be inferred from reflection metadata).
+    const registry = app.get<OpenApiRegistry>(OPENAPI_REGISTRY);
+    const registryDocument = await registry.build({
+      title: config.openapi.title ?? 'API',
+      version: config.openapi.version ?? '0.0.0',
+      description: config.openapi.description,
+    });
+
+    const docBuilder = new DocumentBuilder()
+      .setTitle(config.openapi.title ?? 'API')
+      .setVersion(config.openapi.version ?? '0.0.0');
+    if (config.openapi.description) docBuilder.setDescription(config.openapi.description);
+    if ((config.openapi.auth ?? 'bearer') === 'bearer') docBuilder.addBearerAuth();
+
+    const nestDocument = SwaggerModule.createDocument(app, docBuilder.build());
+
+    // Merge registry-owned component schemas on top of whatever Nest's
+    // decorator scanner produced. Controllers reference schemas by
+    // \`$ref\` (OPENAPI-3), so this merge is what actually resolves the
+    // refs consumers see in /docs-json.
+    // Registry schemas are typed Record<string, unknown> locally
+    // (avoids depending on openapi3-ts); the runtime shape matches Nest's
+    // SchemaObject \u2014 generateSchema(zodRef, false, '3.0') emits valid
+    // OpenAPI 3.0 schema objects. Cast to satisfy Nest's stricter typing.
+    nestDocument.components = {
+      ...nestDocument.components,
+      schemas: {
+        ...(nestDocument.components?.schemas ?? {}),
+        ...registryDocument.components.schemas,
+      } as NonNullable<typeof nestDocument.components>['schemas'],
+    };
+
+    SwaggerModule.setup(config.openapi.path ?? '/docs', app, nestDocument);
+  }
+
+  const port = Number(process.env.PORT ?? 3000);
+  await app.listen(port);
+  // eslint-disable-next-line no-console
+  console.log(\`Application listening on http://localhost:\${port}\`);
+}
+
+bootstrap().catch((err) => {
+  // eslint-disable-next-line no-console
+  console.error('Failed to start application:', err);
+  process.exit(1);
+});
+`;
+}
 function rootSchemaContent() {
   return `/**
  * Drizzle schema root.
@@ -219522,6 +219757,24 @@ async function buildInitPlan(ctx, options) {
       });
     }
   }
+  {
+    const mainPath = path18.join(cwd, "src", "main.ts");
+    if (!fs10.existsSync(mainPath)) {
+      entries.push({
+        path: mainPath,
+        relPath: relOf(cwd, mainPath),
+        action: "create",
+        content: mainTsContent()
+      });
+    } else {
+      entries.push({
+        path: mainPath,
+        relPath: relOf(cwd, mainPath),
+        action: "skip",
+        reason: "exists \u2014 copy the OpenAPI bootstrap block from CONSUMER-SETUP \xA7OpenAPI manually"
+      });
+    }
+  }
   {
     const schemaPath = path18.join(cwd, "src", "schema.ts");
     if (!fs10.existsSync(schemaPath)) {
@@ -219639,7 +219892,22 @@ var init_init_scaffold = __esm({
       // @Body() to give runtime Zod validation at the controller boundary.
       { runtime: "pipes/zod-validation.pipe.ts", target: "src/shared/pipes/zod-validation.pipe.ts" },
       // EAV helpers — referenced by generated services on `eav_value_table` entities
-      { runtime: "eav-helpers.ts", target: "src/shared/eav-helpers.ts" }
+      { runtime: "eav-helpers.ts", target: "src/shared/eav-helpers.ts" },
+      // OpenAPI registry (OPENAPI-1/2) — generated modules register Zod DTOs
+      // here at onModuleInit; OPENAPI-4 mounts Swagger UI off the same registry.
+      // `@anatine/zod-openapi` is an optional peer dep (lazy-imported on build).
+      { runtime: "shared/openapi/registry.ts", target: "src/shared/openapi/registry.ts" },
+      { runtime: "shared/openapi/registry.tokens.ts", target: "src/shared/openapi/registry.tokens.ts" },
+      { runtime: "shared/openapi/errors.ts", target: "src/shared/openapi/errors.ts" },
+      // OPENAPI-3: shared error response schema referenced by every generated
+      // controller's 4xx `@ApiResponse` `$ref`. Auto-registered in the registry
+      // constructor so consumer projects expose `ErrorResponseDto` on
+      // `/docs-json` without per-entity duplication.
+      {
+        runtime: "shared/openapi/error-response.dto.ts",
+        target: "src/shared/openapi/error-response.dto.ts"
+      },
+      { runtime: "shared/openapi/index.ts", target: "src/shared/openapi/index.ts" }
     ];
     REQUIRED_ALIASES = {
       "@shared/*": ["./src/shared/*"],