nestjs-openapi 0.1.0

package/dist/index.mjs

@@ -0,0 +1,297 @@
+export { c as categorizeBrokenRefs, d as defineConfig, f as findConfigFile, e as formatValidationResult, g as generate, b as loadAndResolveConfig, a as loadConfig, l as loadConfigFromFile, r as resolveConfig, v as validateSpec } from './shared/nestjs-openapi.DlNMM8Zq.mjs';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Module } from '@nestjs/common';
+export { generateAsync, generate as generateEffect } from './internal.mjs';
+import { P as ProjectInitError, E as EntryNotFoundError } from './shared/nestjs-openapi.B1bBy_tG.mjs';
+export { a as ConfigLoadError, C as ConfigNotFoundError, b as ConfigValidationError, I as InvalidMethodError, c as getAllControllers, q as getArrayInitializer, o as getControllerMethodInfos, e as getControllerName, d as getControllerPrefix, j as getControllerTags, h as getDecoratorName, k as getHttpDecorator, f as getHttpMethods, m as getMethodInfo, w as getModuleDecoratorArg, z as getModuleMetadata, g as getModules, s as getStringLiteralValue, u as getSymbolFromIdentifier, l as isHttpDecorator, i as isHttpMethod, v as isModuleClass, n as normalizePath, y as resolveArrayOfClasses, x as resolveClassFromExpression, r as resolveClassFromSymbol, t as transformMethod, p as transformMethods } from './shared/nestjs-openapi.B1bBy_tG.mjs';
+import { Context, Effect, Layer } from 'effect';
+import { Project } from 'ts-morph';
+import 'glob';
+import 'js-yaml';
+import 'ts-json-schema-generator';
+import 'node:crypto';
+import 'node:url';
+import 'child_process';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it, done, ctx, k = flags & 7, p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var _OpenApiModule_decorators, _init;
+const PATH_METADATA = "path";
+const METHOD_METADATA = "method";
+const HEADERS_METADATA = "__headers__";
+const CONTROLLER_WATERMARK = "__controller__";
+const OPENAPI_MODULE_OPTIONS = Symbol("OPENAPI_MODULE_OPTIONS");
+const OPENAPI_SPEC = Symbol("OPENAPI_SPEC");
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function generateSwaggerUiHtml(title, jsonPath) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+  <style>
+    html { box-sizing: border-box; overflow-y: scroll; }
+    *, *:before, *:after { box-sizing: inherit; }
+    body { margin: 0; background: #fafafa; }
+  </style>
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"><\/script>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-standalone-preset.js"><\/script>
+  <script>
+    window.onload = function() {
+      SwaggerUIBundle({
+        url: "${escapeHtml(jsonPath)}",
+        dom_id: '#swagger-ui',
+        deepLinking: true,
+        presets: [
+          SwaggerUIBundle.presets.apis,
+          SwaggerUIStandalonePreset
+        ],
+        plugins: [
+          SwaggerUIBundle.plugins.DownloadUrl
+        ],
+        layout: "StandaloneLayout"
+      });
+    };
+  <\/script>
+</body>
+</html>`;
+}
+function loadSpecFile(filePath) {
+  try {
+    const resolvedPath = resolve(process.cwd(), filePath);
+    const content = readFileSync(resolvedPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof Error) {
+      if ("code" in error && error.code === "ENOENT") {
+        throw new Error(
+          `OpenAPI spec file not found: ${filePath}. Make sure to run 'nestjs-openapi generate' first.`
+        );
+      }
+      throw new Error(`Failed to load OpenAPI spec: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function resolveOptions(options) {
+  let swaggerEnabled = false;
+  let swaggerPath = "/api-docs";
+  let swaggerTitle = "";
+  if (options.swagger === true) {
+    swaggerEnabled = true;
+  } else if (options.swagger && typeof options.swagger === "object") {
+    swaggerEnabled = true;
+    swaggerPath = options.swagger.path ?? "/api-docs";
+    swaggerTitle = options.swagger.title ?? "";
+  }
+  return {
+    specFile: options.specFile,
+    enabled: options.enabled ?? true,
+    jsonPath: options.jsonPath ?? "/openapi.json",
+    swagger: {
+      enabled: swaggerEnabled,
+      path: swaggerPath,
+      title: swaggerTitle
+    }
+  };
+}
+_OpenApiModule_decorators = [Module({})];
+let _OpenApiModule = class _OpenApiModule {
+  /**
+   * Configure the OpenAPI module with options.
+   *
+   * @param options - Configuration options
+   * @returns Dynamic module configuration
+   */
+  static forRoot(options) {
+    const resolvedOptions = resolveOptions(options);
+    if (!resolvedOptions.enabled) {
+      return {
+        module: _OpenApiModule,
+        providers: [],
+        controllers: [],
+        exports: []
+      };
+    }
+    const spec = loadSpecFile(resolvedOptions.specFile);
+    const finalOptions = {
+      ...resolvedOptions,
+      swagger: {
+        ...resolvedOptions.swagger,
+        title: resolvedOptions.swagger.title || spec.info.title
+      }
+    };
+    const providers = [
+      {
+        provide: OPENAPI_MODULE_OPTIONS,
+        useValue: finalOptions
+      },
+      {
+        provide: OPENAPI_SPEC,
+        useValue: spec
+      }
+    ];
+    const controllers = createOpenApiControllers(finalOptions, spec);
+    return {
+      module: _OpenApiModule,
+      providers,
+      controllers,
+      exports: [OPENAPI_MODULE_OPTIONS, OPENAPI_SPEC]
+    };
+  }
+};
+_init = __decoratorStart();
+_OpenApiModule = __decorateElement(_init, 0, "OpenApiModule", _OpenApiModule_decorators, _OpenApiModule);
+__runInitializers(_init, 1, _OpenApiModule);
+let OpenApiModule = _OpenApiModule;
+function createJsonController(controllerPath, spec) {
+  class JsonSpecController {
+    getSpec() {
+      return spec;
+    }
+  }
+  Reflect.defineMetadata(CONTROLLER_WATERMARK, true, JsonSpecController);
+  Reflect.defineMetadata(PATH_METADATA, controllerPath, JsonSpecController);
+  const method = JsonSpecController.prototype.getSpec;
+  Reflect.defineMetadata(METHOD_METADATA, 0, method);
+  Reflect.defineMetadata(PATH_METADATA, "/", method);
+  Reflect.defineMetadata(
+    HEADERS_METADATA,
+    [{ name: "Content-Type", value: "application/json" }],
+    method
+  );
+  return JsonSpecController;
+}
+function createSwaggerUiController(controllerPath, title, jsonPath) {
+  class SwaggerUiController {
+    getSwaggerUi() {
+      return generateSwaggerUiHtml(title, jsonPath);
+    }
+  }
+  Reflect.defineMetadata(CONTROLLER_WATERMARK, true, SwaggerUiController);
+  Reflect.defineMetadata(PATH_METADATA, controllerPath, SwaggerUiController);
+  const method = SwaggerUiController.prototype.getSwaggerUi;
+  Reflect.defineMetadata(METHOD_METADATA, 0, method);
+  Reflect.defineMetadata(PATH_METADATA, "/", method);
+  Reflect.defineMetadata(
+    HEADERS_METADATA,
+    [{ name: "Content-Type", value: "text/html" }],
+    method
+  );
+  return SwaggerUiController;
+}
+function createOpenApiControllers(options, spec) {
+  const controllers = [];
+  const jsonController = createJsonController(options.jsonPath, spec);
+  controllers.push(jsonController);
+  if (options.swagger.enabled) {
+    const swaggerUiController = createSwaggerUiController(
+      options.swagger.path,
+      options.swagger.title,
+      options.jsonPath
+    );
+    controllers.push(swaggerUiController);
+  }
+  return controllers;
+}
+
+class ProjectService extends Context.Tag("ProjectService")() {
+}
+const initProject = Effect.fn("ProjectService.initProject")(function* (options) {
+  return yield* Effect.try({
+    try: () => new Project({
+      tsConfigFilePath: options.tsconfig,
+      skipAddingFilesFromTsConfig: true
+    }),
+    catch: (error) => ProjectInitError.create(options.tsconfig, error)
+  });
+});
+const addSourceFiles = Effect.fn("ProjectService.addSourceFiles")(function* (project, entry) {
+  return yield* Effect.try({
+    try: () => {
+      project.addSourceFilesAtPaths(entry);
+      project.resolveSourceFileDependencies();
+    },
+    catch: (error) => new ProjectInitError({
+      tsconfig: "",
+      message: `Failed to add source files: ${entry}`,
+      cause: error
+    })
+  });
+});
+const getEntrySourceFile = Effect.fn("ProjectService.getEntrySourceFile")(
+  function* (project, entry) {
+    const sourceFile = project.getSourceFile(entry);
+    if (!sourceFile) {
+      return yield* EntryNotFoundError.fileNotFound(entry);
+    }
+    return sourceFile;
+  }
+);
+const getEntryClass = Effect.fn("ProjectService.getEntryClass")(function* (sourceFile, entry, className = "AppModule") {
+  const entryClass = sourceFile.getClass(className);
+  if (!entryClass) {
+    return yield* EntryNotFoundError.classNotFound(entry, className);
+  }
+  return entryClass;
+});
+const makeProjectContext = Effect.fn(
+  "ProjectService.makeProjectContext"
+)(function* (options) {
+  yield* Effect.logDebug("Initializing project").pipe(
+    Effect.annotateLogs({ entry: options.entry })
+  );
+  const project = yield* initProject(options);
+  yield* addSourceFiles(project, options.entry);
+  const entrySourceFile = yield* getEntrySourceFile(project, options.entry);
+  const entryClass = yield* getEntryClass(entrySourceFile, options.entry);
+  yield* Effect.logDebug("Project initialized successfully");
+  return {
+    project,
+    entrySourceFile,
+    entryClass
+  };
+});
+const ProjectServiceLive = (options) => Layer.effect(
+  ProjectService,
+  makeProjectContext(options).pipe(Effect.map((context) => ({ context })))
+);
+
+export { EntryNotFoundError, OPENAPI_MODULE_OPTIONS, OPENAPI_SPEC, OpenApiModule, ProjectInitError, ProjectService, ProjectServiceLive, generateSwaggerUiHtml, loadSpecFile, makeProjectContext, resolveOptions };

package/dist/internal.d.mts

@@ -0,0 +1,2 @@
+import 'effect';
+export { G as GenerateOptions, g as generate, d as generateAsync } from './shared/nestjs-openapi.BYUrTaMo.mjs';

package/dist/internal.d.ts

@@ -0,0 +1,2 @@
+import 'effect';
+export { G as GenerateOptions, g as generate, d as generateAsync } from './shared/nestjs-openapi.BYUrTaMo.js';

package/dist/internal.mjs

@@ -0,0 +1,53 @@
+import { Effect } from 'effect';
+import { Project } from 'ts-morph';
+import { E as EntryNotFoundError, g as getModules, o as getControllerMethodInfos, p as transformMethods } from './shared/nestjs-openapi.B1bBy_tG.mjs';
+
+const generate = (options) => Effect.gen(function* () {
+  yield* Effect.logInfo("Starting OpenAPI generation").pipe(
+    Effect.annotateLogs({ entry: options.entry })
+  );
+  const project = new Project({
+    tsConfigFilePath: options.tsconfig,
+    skipAddingFilesFromTsConfig: true
+  });
+  project.addSourceFilesAtPaths(options.entry);
+  project.resolveSourceFileDependencies();
+  const entrySourceFile = project.getSourceFile(options.entry);
+  if (!entrySourceFile) {
+    return yield* EntryNotFoundError.fileNotFound(options.entry);
+  }
+  const entryClass = entrySourceFile.getClass("AppModule");
+  if (!entryClass) {
+    return yield* EntryNotFoundError.classNotFound(
+      options.entry,
+      "AppModule"
+    );
+  }
+  const modules = yield* getModules(entryClass);
+  const methodInfos = modules.flatMap(
+    (mod) => mod.controllers.flatMap(
+      (controller) => getControllerMethodInfos(controller)
+    )
+  );
+  yield* Effect.logInfo("Collected method infos").pipe(
+    Effect.annotateLogs({
+      modules: modules.length,
+      methods: methodInfos.length
+    })
+  );
+  const paths = transformMethods(methodInfos);
+  yield* Effect.logInfo("OpenAPI generation complete").pipe(
+    Effect.annotateLogs({
+      paths: Object.keys(paths).length
+    })
+  );
+  return paths;
+});
+const generateAsync = async (options) => {
+  const program = generate(options).pipe(
+    Effect.mapError((error) => new Error(error.message))
+  );
+  return Effect.runPromise(program);
+};
+
+export { generate, generateAsync };