@cparra/apexdocs 3.0.0-alpha.9 → 3.0.0-beta.1

package/examples/open-api/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "openapi-example",
+  "scripts": {
+    "docs:clean": "rimraf docs",
+    "docs:gen": "ts-node ../../src/cli/generate.ts openapi",
+    "apexdocs:build": "npm run docs:clean && npm run docs:gen"
+  },
+  "devDependencies": {
+    "ts-node": "^10.9.2"
+  },
+  "dependencies": {
+    "rimraf": "^5.0.7"
+  },
+  "apexdocs": {
+    "sourceDir": "force-app",
+    "title": "Open API Example",
+    "namespace": "openapi",
+    "apiVersion": "3.0.0"
+  }
+}

package/examples/open-api/sfdx-project.json

@@ -0,0 +1,12 @@
+{
+  "packageDirectories": [
+    {
+      "path": "force-app",
+      "default": true
+    }
+  ],
+  "name": "openapi",
+  "namespace": "",
+  "sfdcLoginUrl": "https://login.salesforce.com",
+  "sourceApiVersion": "61.0"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cparra/apexdocs",
-  "version": "3.0.0-alpha.9",
+  "version": "3.0.0-beta.1",
   "description": "Library with CLI capabilities to generate documentation for Salesforce Apex classes.",
   "keywords": [
     "apex",

package/src/application/Apexdocs.ts

@@ -4,7 +4,10 @@ import openApi from './generators/openapi';
 import { ApexFileReader } from './apex-file-reader';
 import { DefaultFileSystem } from './file-system';
 import { Logger } from '#utils/logger';
-import { UserDefinedConfig } from '../core/shared/types';
+import { UnparsedSourceFile, UserDefinedConfig, UserDefinedMarkdownConfig } from '../core/shared/types';
+import { pipe } from 'fp-ts/function';
+import * as TE from 'fp-ts/TaskEither';
+import { ReflectionError } from '../core/markdown/reflection/reflect-source';
 
 /**
  * Application entry-point to generate documentation out of Apex source files.
@@ -20,21 +23,50 @@ export class Apexdocs {
       const fileBodies = await ApexFileReader.processFiles(
         new DefaultFileSystem(),
         config.sourceDir,
-        config.includeMetadata,
+        config.targetGenerator === 'markdown' ? config.includeMetadata : false,
       );
 
       switch (config.targetGenerator) {
         case 'markdown':
-          await markdown(fileBodies, config);
+          await generateMarkdownDocumentation(fileBodies, config)();
           break;
         case 'openapi':
-          openApi(fileBodies, config);
+          await openApi(fileBodies, config);
           break;
       }
-
-      Logger.logSingle('✔️ Documentation generated successfully!');
     } catch (error) {
-      Logger.logSingle('❌ An error occurred while generating the documentation.', 'red');
+      Logger.logSingle(`❌ An error occurred while generating the documentation: ${error}`, 'red');
     }
   }
 }
+
+function generateMarkdownDocumentation(fileBodies: UnparsedSourceFile[], config: UserDefinedMarkdownConfig) {
+  return pipe(
+    markdown(fileBodies, config),
+    TE.map(() => Logger.logSingle('✔️ Documentation generated successfully!')),
+    TE.mapLeft((error) => {
+      if (error._tag === 'HookError') {
+        Logger.error('Error(s) occurred while processing hooks. Please review the following issues:');
+        Logger.error(error.error);
+        return;
+      }
+
+      if (error._tag === 'FileWritingError') {
+        Logger.error(error.message);
+        Logger.error(error.error);
+        return;
+      }
+
+      const errorMessages = [
+        'Error(s) occurred while parsing files. Please review the following issues:',
+        ...error.errors.map(formatReflectionError),
+      ].join('\n');
+
+      Logger.error(errorMessages);
+    }),
+  );
+}
+
+function formatReflectionError(error: ReflectionError) {
+  return `Source file: ${error.file}\n${error.message}\n`;
+}

package/src/application/__tests__/apex-file-reader.spec.ts

@@ -1,23 +1,6 @@
-import { Settings, SettingsConfig } from '../../core/settings';
 import { ApexFileReader } from '../apex-file-reader';
 
 describe('File Reader', () => {
-  beforeEach(() => {
-    Settings.build({
-      sourceDirectory: '',
-      recursive: true,
-      scope: [],
-      outputDir: '',
-      targetGenerator: 'markdown',
-      indexOnly: false,
-      defaultGroupName: 'Misc',
-      sanitizeHtml: true,
-      openApiFileName: 'openapi',
-      title: 'Classes',
-      includeMetadata: false,
-    } as SettingsConfig);
-  });
-
   it('returns an empty list when there are no files in the directory', async () => {
     const result = await ApexFileReader.processFiles(
       {

package/src/application/file-writer.ts

@@ -1,21 +1,43 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import * as TE from 'fp-ts/lib/TaskEither';
 import { PageData } from '../core/shared/types';
+import { pipe } from 'fp-ts/function';
 
-export class FileWriter {
-  static write(files: PageData[], outputDir: string, onWriteCallback?: (file: PageData) => void) {
-    files.forEach((file) => {
-      const { outputDocPath, content } = this.getTargetLocation(file, outputDir);
-      fs.mkdirSync(path.dirname(outputDocPath), { recursive: true });
-      fs.writeFileSync(outputDocPath, content, 'utf8');
-      onWriteCallback?.(file);
-    });
-  }
+const mkdir: (path: fs.PathLike, options: fs.MakeDirectoryOptions) => TE.TaskEither<NodeJS.ErrnoException, void> =
+  TE.taskify(fs.mkdir);
 
-  private static getTargetLocation(file: PageData, outputDir: string): PageData {
-    return {
-      ...file,
-      outputDocPath: path.join(outputDir, file.outputDocPath),
-    };
-  }
+const writeFile: (
+  path: fs.PathOrFileDescriptor,
+  data: string,
+  options?: fs.WriteFileOptions,
+) => TE.TaskEither<NodeJS.ErrnoException, void> = TE.taskify(fs.writeFile);
+
+export function writeFiles(files: PageData[], outputDir: string, onWriteCallback?: (file: PageData) => void) {
+  return pipe(
+    files,
+    TE.traverseArray((file) => writeSingle(file, outputDir, onWriteCallback)),
+  );
+}
+
+function writeSingle(file: PageData, outputDir: string, onWriteCallback?: (file: PageData) => void) {
+  const ensureDirectoryExists = ({ outputDocPath }: PageData) =>
+    mkdir(path.dirname(outputDocPath), { recursive: true });
+
+  const writeContents = (file: PageData) => writeFile(file.outputDocPath, file.content, 'utf8');
+
+  return pipe(
+    resolveTargetLocation(file, outputDir),
+    (file) => TE.right(file),
+    TE.tapIO(ensureDirectoryExists),
+    TE.flatMap(writeContents),
+    TE.map(() => onWriteCallback?.(file)),
+  );
+}
+
+function resolveTargetLocation(file: PageData, outputDir: string): PageData {
+  return {
+    ...file,
+    outputDocPath: path.join(outputDir, file.outputDocPath),
+  };
 }

package/src/application/generators/markdown.ts

@@ -1,6 +1,4 @@
 import { generateDocs } from '../../core/markdown/generate-docs';
-import { FileWriter } from '../file-writer';
-import { Logger } from '#utils/logger';
 import { pipe } from 'fp-ts/function';
 import {
   PageData,
@@ -11,10 +9,11 @@ import {
 import { referenceGuideTemplate } from '../../core/markdown/templates/reference-guide';
 import * as TE from 'fp-ts/TaskEither';
 import { isSkip } from '../../core/shared/utils';
-import { ReflectionError } from '../../core/markdown/reflection/reflect-source';
+import { writeFiles } from '../file-writer';
 
 class FileWritingError {
   readonly _tag = 'FileWritingError';
+
   constructor(
     public message: string,
     public error: unknown,
@@ -25,27 +24,7 @@ export default function generate(bundles: UnparsedSourceFile[], config: UserDefi
   return pipe(
     generateDocumentationBundle(bundles, config),
     TE.flatMap((files) => writeFilesToSystem(files, config.targetDir)),
-    TE.mapLeft((error) => {
-      if (error._tag === 'HookError') {
-        Logger.error('Error(s) occurred while processing hooks. Please review the following issues:');
-        Logger.error(error.error);
-        return;
-      }
-
-      if (error._tag === 'FileWritingError') {
-        Logger.error(error.message);
-        Logger.error(error.error);
-        return;
-      }
-
-      const errorMessages = [
-        'Error(s) occurred while parsing files. Please review the following issues:',
-        ...error.errors.map(formatReflectionError),
-      ].join('\n');
-
-      Logger.error(errorMessages);
-    }),
-  )();
+  );
 }
 
 function generateDocumentationBundle(bundles: UnparsedSourceFile[], config: UserDefinedMarkdownConfig) {
@@ -56,19 +35,11 @@ function generateDocumentationBundle(bundles: UnparsedSourceFile[], config: User
 }
 
 function writeFilesToSystem(files: PostHookDocumentationBundle, outputDir: string) {
-  try {
-    FileWriter.write(
-      [files.referenceGuide, ...files.docs]
-        // Filter out any files that should be skipped
-        .filter((file) => !isSkip(file)) as PageData[],
-      outputDir,
-    );
-    return TE.right(undefined);
-  } catch (error) {
-    return TE.left(new FileWritingError('An error occurred while writing files to the system.', error));
-  }
-}
-
-function formatReflectionError(error: ReflectionError) {
-  return `Source file: ${error.file}\n${error.message}\n`;
+  return pipe(
+    [files.referenceGuide, ...files.docs].filter((file) => !isSkip(file)),
+    (files) => writeFiles(files as PageData[], outputDir),
+    TE.mapLeft((error) => {
+      return new FileWritingError('An error occurred while writing files to the system.', error);
+    }),
+  );
 }

package/src/application/generators/openapi.ts

@@ -2,15 +2,27 @@ import { createManifest } from '../../core/openapi/manifest-factory';
 import { RawBodyParser } from '../../core/openapi/parser';
 import { TypesRepository } from '../../core/openapi/types-repository';
 import Transpiler from '../../core/openapi/transpiler';
-import { FileWriter } from '../file-writer';
 import { Logger } from '#utils/logger';
 import ErrorLogger from '#utils/error-logger';
 import { reflect, ReflectionResult } from '@cparra/apex-reflection';
 import Manifest from '../../core/manifest';
 import { PageData, UnparsedSourceFile, UserDefinedOpenApiConfig } from '../../core/shared/types';
 import { OpenApiDocsProcessor } from '../../core/openapi/open-api-docs-processor';
+import { writeFiles } from '../file-writer';
+import { pipe } from 'fp-ts/function';
+import * as TE from 'fp-ts/TaskEither';
+import { OpenApiSettings } from '../../core/openApiSettings';
+
+export default async function openApi(fileBodies: UnparsedSourceFile[], config: UserDefinedOpenApiConfig) {
+  OpenApiSettings.build({
+    sourceDirectory: config.sourceDir,
+    outputDir: config.targetDir,
+    openApiFileName: config.fileName,
+    openApiTitle: config.title,
+    namespace: config.namespace,
+    version: config.apiVersion,
+  });
 
-export default function openApi(fileBodies: UnparsedSourceFile[], config: UserDefinedOpenApiConfig) {
   const manifest = createManifest(new RawBodyParser(fileBodies), reflectionWithLogger);
   TypesRepository.getInstance().populateAll(manifest.types);
   const filteredTypes = filterByScopes(manifest);
@@ -18,11 +30,15 @@ export default function openApi(fileBodies: UnparsedSourceFile[], config: UserDe
   Transpiler.generate(filteredTypes, processor);
   const generatedFiles = processor.fileBuilder().files();
 
-  FileWriter.write(generatedFiles, config.targetDir, (file: PageData) => {
-    Logger.logSingle(`${file.outputDocPath} processed.`, 'green');
-  });
+  await pipe(
+    writeFiles(generatedFiles, config.targetDir, (file: PageData) => {
+      Logger.logSingle(`${file.outputDocPath} processed.`, 'green');
+    }),
+    TE.map(() => Logger.logSingle('✔️ Documentation generated successfully!')),
+    TE.mapError((error) => Logger.error(error)),
+  )();
 
-  // Error logging
+  // Logs any errors that the types might have in their doc comment's error field
   ErrorLogger.logErrors(filteredTypes);
 }
 

package/src/cli/args.ts

@@ -3,6 +3,7 @@ import * as yargs from 'yargs';
 import { UserDefinedMarkdownConfig } from '../core/shared/types';
 import { TypeScriptLoader } from 'cosmiconfig-typescript-loader';
 import { markdownOptions } from './commands/markdown';
+import { openApiOptions } from './commands/openapi';
 
 /**
  * Extracts configuration from a configuration file or the package.json
@@ -26,7 +27,9 @@ function _extractYargs(config?: CosmiconfigResult) {
     .command('markdown', 'Generate documentation from Apex classes as a Markdown site.', (yargs) =>
       yargs.options(markdownOptions),
     )
-    .command('openapi', 'Generate an OpenApi REST specification from Apex classes.') // TODO: Add OpenApi specific options
+    .command('openapi', 'Generate an OpenApi REST specification from Apex classes.', () =>
+      yargs.options(openApiOptions),
+    )
     .demandCommand()
     .parseSync();
 }

package/src/cli/commands/openapi.ts

@@ -0,0 +1,36 @@
+import { Options } from 'yargs';
+import { defaults } from '../../defaults';
+
+export const openApiOptions: { [key: string]: Options } = {
+  sourceDir: {
+    type: 'string',
+    alias: 's',
+    demandOption: true,
+    describe: 'The directory location which contains your apex .cls classes.',
+  },
+  targetDir: {
+    type: 'string',
+    alias: 't',
+    default: defaults.targetDir,
+    describe: 'The directory location where the OpenApi file will be generated.',
+  },
+  fileName: {
+    type: 'string',
+    default: 'openapi',
+    describe: 'The name of the OpenApi file to be generated.',
+  },
+  namespace: {
+    type: 'string',
+    describe: 'The package namespace, if any. This will be added to the API file Server Url.',
+  },
+  title: {
+    type: 'string',
+    default: 'Apex REST API',
+    describe: 'The title of the OpenApi file.',
+  },
+  apiVersion: {
+    type: 'string',
+    default: '1.0.0',
+    describe: 'The version of the OpenApi file.',
+  },
+};

package/src/core/markdown/adapters/documentables.ts

@@ -98,7 +98,6 @@ export function adaptDocumentable(
         .map((currentAnnotation) => currentAnnotation.body) ?? []
     );
   }
-
   return {
     ...adaptDescribable(documentable.docComment?.descriptionLines, linkGenerator),
     annotations: documentable.annotations.map((annotation) => annotation.type.toUpperCase()),

package/src/core/markdown/generate-docs.ts

@@ -1,5 +1,4 @@
 import { pipe } from 'fp-ts/function';
-//import * as E from 'fp-ts/Either';
 import * as TE from 'fp-ts/TaskEither';
 import yaml from 'js-yaml';
 
@@ -20,8 +19,7 @@ import {
   ParsedFile,
 } from '../shared/types';
 import { parsedFilesToRenderableBundle } from './adapters/renderable-bundle';
-import { myPipeSeq /*reflectSourceCode*/ } from './reflection/reflect-source';
-//import { checkForReflectionErrors } from './reflection/error-handling';
+import { reflectBundles } from './reflection/reflect-source';
 import { addInheritanceChainToTypes } from './reflection/inheritance-chain-expanion';
 import { addInheritedMembersToTypes } from './reflection/inherited-member-expansion';
 import { convertToDocumentationBundle } from './adapters/renderable-to-page-data';
@@ -63,8 +61,7 @@ export function generateDocs(apexBundles: UnparsedSourceFile[], config: Markdown
 
   return pipe(
     apexBundles,
-    myPipeSeq,
-    //checkForReflectionErrors,
+    reflectBundles,
     TE.map(filterOutOfScope),
     TE.map(addInheritedMembersToTypes),
     TE.map(addInheritanceChainToTypes),

package/src/core/markdown/reflection/reflect-source.ts

@@ -1,13 +1,13 @@
 import { ParsedFile, UnparsedSourceFile } from '../../shared/types';
-//import * as E from 'fp-ts/Either';
 import * as TE from 'fp-ts/TaskEither';
+import * as E from 'fp-ts/Either';
 import * as T from 'fp-ts/Task';
 import * as A from 'fp-ts/lib/Array';
-import { reflect as mirrorReflection, Type } from '@cparra/apex-reflection';
+import { Annotation, reflect as mirrorReflection, Type } from '@cparra/apex-reflection';
 import { pipe } from 'fp-ts/function';
 import * as O from 'fp-ts/Option';
 import { parseApexMetadata } from '../../parse-apex-metadata';
-import { ParsingError } from '@cparra/apex-reflection/index';
+import { ParsingError } from '@cparra/apex-reflection';
 import { apply } from '#utils/fp';
 import { Semigroup } from 'fp-ts/Semigroup';
 
@@ -37,20 +37,20 @@ async function reflectAsync(rawSource: string): Promise<Type> {
   });
 }
 
-export function myPipeSeq(apexBundles: UnparsedSourceFile[]) {
+export function reflectBundles(apexBundles: UnparsedSourceFile[]) {
   const semiGroupReflectionError: Semigroup<ReflectionErrors> = {
     concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors]),
   };
   const Ap = TE.getApplicativeTaskValidation(T.ApplyPar, semiGroupReflectionError);
 
-  return pipe(apexBundles, A.traverse(Ap)(myPipe));
+  return pipe(apexBundles, A.traverse(Ap)(reflectBundle));
 }
 
-function myPipe(apexBundle: UnparsedSourceFile): TE.TaskEither<ReflectionErrors, ParsedFile> {
+function reflectBundle(apexBundle: UnparsedSourceFile): TE.TaskEither<ReflectionErrors, ParsedFile> {
   const convertToParsedFile: (typeMirror: Type) => ParsedFile = apply(toParsedFile, apexBundle.filePath);
-  const withMetadata: (parsedFile: ParsedFile) => ParsedFile = apply(addMetadata, apexBundle.metadataContent);
+  const withMetadata = apply(addMetadata, apexBundle.metadataContent);
 
-  return pipe(apexBundle, reflectAsTask, TE.map(convertToParsedFile), TE.map(withMetadata));
+  return pipe(apexBundle, reflectAsTask, TE.map(convertToParsedFile), TE.flatMap(withMetadata));
 }
 
 function reflectAsTask(apexBundle: UnparsedSourceFile): TE.TaskEither<ReflectionErrors, Type> {
@@ -72,51 +72,52 @@ function toParsedFile(filePath: string, typeMirror: Type): ParsedFile {
   };
 }
 
-function addMetadata(rawMetadataContent: string | null, parsedFile: ParsedFile) {
-  return {
-    ...parsedFile,
-    type: addFileMetadataToTypeAnnotation(parsedFile.type, rawMetadataContent),
-  };
+function addMetadata(
+  rawMetadataContent: string | null,
+  parsedFile: ParsedFile,
+): TE.TaskEither<ReflectionErrors, ParsedFile> {
+  return TE.fromEither(
+    pipe(
+      parsedFile.type,
+      (type) => addFileMetadataToTypeAnnotation(type, rawMetadataContent),
+      E.map((type) => ({ ...parsedFile, type })),
+      E.mapLeft((error) => errorToReflectionErrors(error, parsedFile.source.filePath)),
+    ),
+  );
 }
 
-// TODO: Not Async below
-
-// export function reflectSourceCode(apexBundles: UnparsedSourceFile[]) {
-//   return apexBundles.map(reflectSourceBody);
-// }
-//
-// function reflectSourceBody(apexBundle: UnparsedSourceFile): E.Either<ReflectionError, ParsedFile> {
-//   const { filePath, content: input, metadataContent: metadata } = apexBundle;
-//   const result = mirrorReflection(input);
-//   return result.error
-//     ? E.left(new ReflectionError(filePath, result.error.message))
-//     : E.right({
-//         source: {
-//           filePath,
-//           name: result.typeMirror!.name,
-//           type: result.typeMirror!.type_name,
-//         },
-//         type: addFileMetadataToTypeAnnotation(result.typeMirror!, metadata),
-//       });
-// }
-
-function addFileMetadataToTypeAnnotation(type: Type, metadata: string | null): Type {
+function errorToReflectionErrors(error: Error, filePath: string): ReflectionErrors {
+  return new ReflectionErrors([new ReflectionError(filePath, error.message)]);
+}
+
+function addFileMetadataToTypeAnnotation(type: Type, metadata: string | null): E.Either<Error, Type> {
+  const concatAnnotationToType = apply(concatAnnotations, type);
+
   return pipe(
     O.fromNullable(metadata),
-    O.map((metadata) => {
-      // TODO: Do we need to error check this, as it is coming from an external library?
-      // Or maybe what we do is return the Either from the parse-apex-metadata function?
-      const metadataParams = parseApexMetadata(metadata);
-      metadataParams.forEach((value, key) => {
-        const declaration = `${key}: ${value}`;
-        type.annotations.push({
-          rawDeclaration: declaration,
-          name: declaration,
-          type: declaration,
-        });
-      });
-      return type;
-    }),
-    O.getOrElse(() => type),
+    O.map(concatAnnotationToType),
+    O.getOrElse(() => E.right(type)),
   );
 }
+
+function concatAnnotations(type: Type, metadataInput: string): E.Either<Error, Type> {
+  return pipe(
+    metadataInput,
+    parseApexMetadata,
+    E.map((metadataMap) => ({
+      ...type,
+      annotations: [...type.annotations, ...mapToAnnotations(metadataMap)],
+    })),
+  );
+}
+
+function mapToAnnotations(metadata: Map<string, string>): Annotation[] {
+  return Array.from(metadata.entries()).map(([key, value]) => {
+    const declaration = `${key}: ${value}`;
+    return {
+      name: declaration,
+      type: declaration,
+      rawDeclaration: declaration,
+    };
+  });
+}

package/src/core/openApiSettings.ts

@@ -0,0 +1,41 @@
+export interface SettingsConfig {
+  sourceDirectory: string;
+  outputDir: string;
+  openApiFileName: string;
+  namespace?: string;
+  openApiTitle?: string;
+  version: string;
+}
+
+export class OpenApiSettings {
+  private static instance: OpenApiSettings;
+
+  private constructor(public config: SettingsConfig) {}
+
+  public static build(config: SettingsConfig) {
+    OpenApiSettings.instance = new OpenApiSettings(config);
+  }
+
+  public static getInstance(): OpenApiSettings {
+    if (!OpenApiSettings.instance) {
+      throw new Error('Settings has not been initialized');
+    }
+    return OpenApiSettings.instance;
+  }
+
+  public getOpenApiTitle(): string | undefined {
+    return this.config.openApiTitle;
+  }
+
+  public getNamespace(): string | undefined {
+    return this.config.namespace;
+  }
+
+  public openApiFileName(): string {
+    return this.config.openApiFileName;
+  }
+
+  public getVersion(): string {
+    return this.config.version;
+  }
+}

package/src/core/openapi/__tests__/open-api-docs-processor.spec.ts

@@ -1,12 +1,12 @@
 import { OpenApiDocsProcessor } from '../open-api-docs-processor';
-import { Settings } from '../../settings';
+import { OpenApiSettings } from '../../openApiSettings';
 import { SettingsBuilder } from '../../../test-helpers/SettingsBuilder';
 import { DocCommentBuilder } from '../../../test-helpers/DocCommentBuilder';
 import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';
 import { ClassMirrorBuilder } from '../../../test-helpers/ClassMirrorBuilder';
 
 beforeEach(() => {
-  Settings.build(new SettingsBuilder().build());
+  OpenApiSettings.build(new SettingsBuilder().build());
 });
 
 it('should add a path based on the @UrlResource annotation on the class', function () {

package/src/core/openapi/open-api-docs-processor.ts

@@ -2,7 +2,7 @@ import { FileContainer } from './file-container';
 import { ClassMirror, Type } from '@cparra/apex-reflection';
 import { Logger } from '#utils/logger';
 import { OpenApi } from './open-api';
-import { Settings } from '../settings';
+import { OpenApiSettings } from '../openApiSettings';
 import { MethodParser } from './parsers/MethodParser';
 import { camel2title } from '#utils/string-utils';
 import { createOpenApiFile } from './openapi-type-file';
@@ -13,11 +13,15 @@ export class OpenApiDocsProcessor {
 
   constructor() {
     this._fileContainer = new FileContainer();
-    const title = Settings.getInstance().getOpenApiTitle();
+    const title = OpenApiSettings.getInstance().getOpenApiTitle();
     if (!title) {
       throw Error('No OpenApi title was provided.');
     }
-    this.openApiModel = new OpenApi(title, '1.0.0', Settings.getInstance().getNamespace());
+    this.openApiModel = new OpenApi(
+      title,
+      OpenApiSettings.getInstance().getVersion(),
+      OpenApiSettings.getInstance().getNamespace(),
+    );
   }
 
   fileBuilder(): FileContainer {
@@ -66,7 +70,7 @@ export class OpenApiDocsProcessor {
   }
 
   onAfterProcess: ((types: Type[]) => void) | undefined = () => {
-    const page = createOpenApiFile(Settings.getInstance().openApiFileName(), this.openApiModel);
+    const page = createOpenApiFile(OpenApiSettings.getInstance().openApiFileName(), this.openApiModel);
     this._fileContainer.pushFile(page);
   };
 

package/src/core/openapi/open-api.ts

@@ -15,7 +15,11 @@ export class OpenApi {
   servers: ServerObject[];
   components?: ComponentsObject;
 
-  constructor(title: string, version: string, private namespace?: string) {
+  constructor(
+    title: string,
+    version: string,
+    private namespace?: string,
+  ) {
     this.info = {
       title: title,
       version: version,