@cparra/apexdocs 2.25.0-alpha.8 → 2.25.0

package/src/settings.ts

@@ -0,0 +1,147 @@
+import { GeneratorChoices } from './transpiler/generator-choices';
+
+export type OnBeforeFileWrite = (file: TargetFile) => TargetFile;
+
+export type TargetFile = {
+  name: string;
+  extension: string;
+  dir: OutputDir;
+};
+
+export type OutputDir = {
+  baseDir: string;
+  fileDir: string;
+};
+
+export type TargetType = {
+  name: string;
+  typeName: 'class' | 'interface' | 'enum';
+  accessModifier: string;
+  description?: string;
+  group?: string;
+};
+
+export interface SettingsConfig {
+  sourceDirectory: string;
+  recursive: boolean;
+  scope: string[];
+  outputDir: string;
+  targetGenerator: GeneratorChoices;
+  indexOnly: boolean;
+  defaultGroupName: string;
+  sanitizeHtml: boolean;
+  openApiTitle?: string;
+  title: string;
+  namespace?: string;
+  openApiFileName: string;
+  includeMetadata: boolean;
+  rootDir?: string;
+  sortMembersAlphabetically?: boolean;
+  onAfterProcess?: (files: TargetFile[]) => void;
+  onBeforeFileWrite?: (file: TargetFile) => TargetFile;
+  frontMatterHeader?: (file: TargetType) => string[];
+}
+
+export class Settings {
+  private static instance: Settings;
+
+  private constructor(public config: SettingsConfig) {}
+
+  public static build(config: SettingsConfig) {
+    Settings.instance = new Settings(config);
+  }
+
+  public static getInstance(): Settings {
+    if (!Settings.instance) {
+      throw new Error('Settings has not been initialized');
+    }
+    return Settings.instance;
+  }
+
+  get sourceDirectory(): string {
+    return this.config.sourceDirectory;
+  }
+
+  get recursive(): boolean {
+    return this.config.recursive;
+  }
+
+  get scope(): string[] {
+    return this.config.scope;
+  }
+
+  get outputDir(): string {
+    return this.config.outputDir;
+  }
+
+  get targetGenerator(): GeneratorChoices {
+    return this.config.targetGenerator;
+  }
+
+  get indexOnly(): boolean {
+    return this.config.indexOnly;
+  }
+
+  get sanitizeHtml(): boolean {
+    return this.config.sanitizeHtml;
+  }
+
+  public getDefaultGroupName(): string {
+    return this.config.defaultGroupName;
+  }
+
+  public getOpenApiTitle(): string | undefined {
+    return this.config.openApiTitle ?? this.config.title;
+  }
+
+  public getTitle(): string {
+    return this.config.title;
+  }
+
+  public getNamespace(): string | undefined {
+    return this.config.namespace;
+  }
+
+  public getNamespacePrefix(): string {
+    if (!this.config.namespace) {
+      return '';
+    }
+    return `${this.config.namespace}.`;
+  }
+
+  public openApiFileName(): string {
+    return this.config.openApiFileName;
+  }
+
+  public includeMetadata(): boolean {
+    return this.config.includeMetadata;
+  }
+
+  public sortMembersAlphabetically(): boolean {
+    return this.config.sortMembersAlphabetically ?? false;
+  }
+
+  public getRootDir(): string | undefined {
+    return this.config.rootDir;
+  }
+
+  public onAfterProcess(files: TargetFile[]): void {
+    if (this.config.onAfterProcess) {
+      this.config.onAfterProcess(files);
+    }
+  }
+
+  public onBeforeFileWrite(file: TargetFile): TargetFile {
+    if (this.config.onBeforeFileWrite) {
+      return this.config.onBeforeFileWrite(file);
+    }
+    return file;
+  }
+
+  public frontMatterHeader(file: TargetType): string[] {
+    if (this.config.frontMatterHeader) {
+      return this.config.frontMatterHeader(file);
+    }
+    return [];
+  }
+}

package/src/test-helpers/ClassMirrorBuilder.ts

@@ -10,8 +10,6 @@ export class ClassMirrorBuilder {
   private docComment?: DocComment;
   private methods: MethodMirror[] = [];
   private fields: FieldMirror[] = [];
-  private innerClasses: ClassMirror[] = [];
-  private extendedClass: string | undefined;
 
   withName(name: string): ClassMirrorBuilder {
     this.name = name;
@@ -38,16 +36,6 @@ export class ClassMirrorBuilder {
     return this;
   }
 
-  addInnerClass(innerClass: ClassMirror): ClassMirrorBuilder {
-    this.innerClasses.push(innerClass);
-    return this;
-  }
-
-  withExtendedClass(extendedClass: string): ClassMirrorBuilder {
-    this.extendedClass = extendedClass;
-    return this;
-  }
-
   build(): ClassMirror {
     return {
       annotations: this.annotations,
@@ -60,10 +48,9 @@ export class ClassMirrorBuilder {
       constructors: [],
       enums: [],
       interfaces: [],
-      classes: this.innerClasses,
+      classes: [],
       access_modifier: 'public',
       docComment: this.docComment,
-      extended_class: this.extendedClass,
     };
   }
 }

package/src/test-helpers/FieldMirrorBuilder.ts

@@ -1,5 +1,5 @@
 import { DocComment, FieldMirror } from '@cparra/apex-reflection';
-import { ReferencedType } from '@cparra/apex-reflection';
+import { ReferencedType } from '@cparra/apex-reflection/index';
 
 type MemberModifier = 'static' | 'webservice' | 'final' | 'override' | 'testmethod' | 'transient';
 

package/src/test-helpers/MethodMirrorBuilder.ts

@@ -1,16 +1,9 @@
-import { Annotation, DocComment, MethodMirror, ParameterMirror } from '@cparra/apex-reflection';
-
-type Parameter = ParameterMirror;
+import { Annotation, DocComment, MethodMirror } from '@cparra/apex-reflection';
 
 export class MethodMirrorBuilder {
   private name = 'sampleMethod';
   private annotations: Annotation[] = [];
   private docComment?: DocComment;
-  private typeReference: { type: string; rawDeclaration: string } = {
-    type: 'void',
-    rawDeclaration: 'void',
-  };
-  private parameters: Parameter[] = [];
 
   withName(name: string): MethodMirrorBuilder {
     this.name = name;
@@ -27,51 +20,18 @@ export class MethodMirrorBuilder {
     return this;
   }
 
-  withTypeReference(param: { type: string; rawDeclaration: string }) {
-    this.typeReference = param;
-    return this;
-  }
-
-  addParameter(parameter: Parameter): MethodMirrorBuilder {
-    this.parameters.push(parameter);
-    return this;
-  }
-
   build(): MethodMirror {
     return {
       access_modifier: 'public',
       annotations: this.annotations,
       name: this.name,
       memberModifiers: [],
-      typeReference: this.typeReference,
-      parameters: this.parameters,
+      typeReference: {
+        type: 'void',
+        rawDeclaration: 'void',
+      },
+      parameters: [],
       docComment: this.docComment,
     };
   }
 }
-
-export class ParameterBuilder {
-  private name = 'param';
-  private typeReference: { type: string; rawDeclaration: string } = {
-    type: 'String',
-    rawDeclaration: 'String',
-  };
-
-  withName(name: string): ParameterBuilder {
-    this.name = name;
-    return this;
-  }
-
-  withTypeReference(param: { type: string; rawDeclaration: string }) {
-    this.typeReference = param;
-    return this;
-  }
-
-  build(): Parameter {
-    return {
-      memberModifiers: [],
-      name: this.name,
-      typeReference: this.typeReference,
-    };
-  }
-}

package/src/test-helpers/SettingsBuilder.ts

@@ -1,4 +1,4 @@
-import { SettingsConfig } from '../core/settings';
+import { SettingsConfig } from '../settings';
 
 /**
  * Builder class to create SettingsConfig objects.
@@ -8,13 +8,16 @@ export class SettingsBuilder {
   build(): SettingsConfig {
     return {
       sourceDirectory: './',
+      recursive: true,
       scope: [],
       outputDir: './',
       targetGenerator: 'openapi',
       indexOnly: false,
       defaultGroupName: 'Misc',
+      sanitizeHtml: true,
       openApiTitle: 'Apex API',
       openApiFileName: 'openapi',
+      title: 'Classes',
       includeMetadata: false,
     };
   }

package/src/transpiler/factory.ts

@@ -0,0 +1,33 @@
+import ProcessorTypeTranspiler from './processor-type-transpiler';
+import { GeneratorChoices } from './generator-choices';
+import { JekyllDocsProcessor } from './markdown/jekyll/jekyll-docsProcessor';
+import DocsifyDocsProcessor from './markdown/docsify/docsify-docs-processor';
+import { PlainMarkdownDocsProcessor } from './markdown/plain-markdown/plain-docsProcessor';
+import { OpenApiDocsProcessor } from './openapi/open-api-docs-processor';
+
+export class TypeTranspilerFactory {
+  private static typeTranspilerCache?: ProcessorTypeTranspiler;
+
+  public static get(generator: GeneratorChoices): ProcessorTypeTranspiler {
+    if (this.typeTranspilerCache) {
+      return this.typeTranspilerCache;
+    }
+
+    switch (generator) {
+      case 'jekyll':
+        this.typeTranspilerCache = new JekyllDocsProcessor();
+        return this.typeTranspilerCache;
+      case 'docsify':
+        this.typeTranspilerCache = new DocsifyDocsProcessor();
+        return this.typeTranspilerCache;
+      case 'plain-markdown':
+        this.typeTranspilerCache = new PlainMarkdownDocsProcessor();
+        return this.typeTranspilerCache;
+      case 'openapi':
+        this.typeTranspilerCache = new OpenApiDocsProcessor();
+        return this.typeTranspilerCache;
+      default:
+        throw Error('Invalid target generator');
+    }
+  }
+}

package/src/transpiler/file-container.ts

@@ -0,0 +1,13 @@
+import { OutputFile } from '../model/outputFile';
+
+export class FileContainer {
+  _files: OutputFile[] = [];
+
+  files(): OutputFile[] {
+    return this._files;
+  }
+
+  pushFile(file: OutputFile): void {
+    this._files.push(file);
+  }
+}

package/src/transpiler/generator-choices.ts

@@ -0,0 +1 @@
+export type GeneratorChoices = 'jekyll' | 'docsify' | 'plain-markdown' | 'openapi';

package/src/transpiler/markdown/class-file-generatorHelper.ts

@@ -0,0 +1,58 @@
+import { Type } from '@cparra/apex-reflection';
+import { TypesRepository } from '../../model/types-repository';
+import { Settings } from '../../settings';
+import State from '../../service/state';
+import { TypeTranspilerFactory } from '../factory';
+
+export default class ClassFileGeneratorHelper {
+  public static getSanitizedGroup(classModel: Type) {
+    return this.getClassGroup(classModel).replace(/ /g, '-').replace('.', '');
+  }
+
+  public static getFileLink(classModel: Type) {
+    const documentationRoot = Settings.getInstance().getRootDir() ?? '';
+    const directoryRoot = `${documentationRoot}${this.getDirectoryRoot(classModel)}`;
+    const fullClassName = `${Settings.getInstance().getNamespacePrefix()}${classModel.name}`;
+    return `[${fullClassName}](${directoryRoot}${fullClassName}.md)`;
+  }
+
+  public static getFileLinkByTypeName(typeName: string) {
+    const type = TypesRepository.getInstance().getFromScopedByName(typeName);
+    if (!type) {
+      // If the type is not found, we return a Markdown hyperlink with whatever we received.
+      return `[${typeName}](${typeName})`;
+    }
+
+    return this.getFileLink(type);
+  }
+
+  private static getDirectoryRoot(classModel: Type) {
+    // root-relative links start from the root by using a leading '/'
+    const generator = Settings.getInstance().targetGenerator;
+    if (TypeTranspilerFactory.get(generator).getLinkingStrategy() === 'root-relative') {
+      return `/${this.getSanitizedGroup(classModel)}/`;
+    }
+
+    // path-relative links traverse the directory structure
+    const typeBeingProcessed = State.getInstance().getTypeBeingProcessed();
+    if (typeBeingProcessed) {
+      if (this.getClassGroup(typeBeingProcessed) === this.getClassGroup(classModel)) {
+        // If the types the same groups then we simply link directly to that file
+        return './';
+      } else {
+        // If the types have different groups, then we have to go up a directory
+        return `../${this.getSanitizedGroup(classModel)}/`;
+      }
+    } else {
+      // If nothing is being processed, then we assume we are at the root and links should include the groups
+      return `./${this.getSanitizedGroup(classModel)}/`;
+    }
+  }
+
+  private static getClassGroup(classModel: Type): string {
+    const groupAnnotation = classModel.docComment?.annotations.find(
+      (annotation) => annotation.name.toLowerCase() === 'group',
+    );
+    return groupAnnotation?.body ?? Settings.getInstance().getDefaultGroupName();
+  }
+}

package/src/transpiler/markdown/docsify/docsify-docs-processor.ts

@@ -0,0 +1,12 @@
+import { MarkdownTranspilerBase } from '../markdown-transpiler-base';
+import { LinkingStrategy } from '../../processor-type-transpiler';
+
+export default class DocsifyDocsProcessor extends MarkdownTranspilerBase {
+  homeFileName(): string {
+    return 'README';
+  }
+
+  getLinkingStrategy(): LinkingStrategy {
+    return 'root-relative';
+  }
+}

package/src/transpiler/markdown/jekyll/jekyll-docsProcessor.ts

@@ -0,0 +1,50 @@
+import { MarkdownTranspilerBase } from '../markdown-transpiler-base';
+import { Type } from '@cparra/apex-reflection';
+import { MarkdownHomeFile } from '../../../model/markdown-home-file';
+import { MarkdownTypeFile } from '../../../model/markdown-type-file';
+import { LinkingStrategy } from '../../processor-type-transpiler';
+import { Settings } from '../../../settings';
+
+export class JekyllDocsProcessor extends MarkdownTranspilerBase {
+  homeFileName(): string {
+    return 'index';
+  }
+
+  onBeforeProcess = (types: Type[]) => {
+    this._fileContainer.pushFile(new MarkdownHomeFile(this.homeFileName(), types, this.frontMatterForHomeFile));
+  };
+
+  onProcess(type: Type): void {
+    this._fileContainer.pushFile(new MarkdownTypeFile(type, 1, this.getFrontMatterHeader(type)));
+  }
+
+  get frontMatterForHomeFile(): string {
+    return '---\nlayout: default\n---';
+  }
+
+  getFrontMatterHeader(type: Type): string {
+    const headerLines = ['---'];
+    // "layout: default" is a required front matter header for Jekyll
+    headerLines.push('layout: default');
+    // Add any additional front matter headers that might have been configured in the settings
+    const targetType = {
+      name: type.name,
+      typeName: type.type_name,
+      accessModifier: type.access_modifier,
+      group: type.group,
+      description: type.docComment?.description,
+    };
+    const configuredHeaders = Settings.getInstance().frontMatterHeader(targetType);
+    if (configuredHeaders) {
+      configuredHeaders.forEach((header) => {
+        headerLines.push(header);
+      });
+    }
+    headerLines.push('---');
+    return headerLines.join('\n');
+  }
+
+  getLinkingStrategy(): LinkingStrategy {
+    return 'path-relative';
+  }
+}

package/src/transpiler/markdown/markdown-transpiler-base.ts

@@ -0,0 +1,28 @@
+import ProcessorTypeTranspiler from '../processor-type-transpiler';
+import { Type } from '@cparra/apex-reflection';
+import { FileContainer } from '../file-container';
+import { MarkdownHomeFile } from '../../model/markdown-home-file';
+import { MarkdownTypeFile } from '../../model/markdown-type-file';
+
+export abstract class MarkdownTranspilerBase extends ProcessorTypeTranspiler {
+  protected readonly _fileContainer: FileContainer;
+
+  constructor() {
+    super();
+    this._fileContainer = new FileContainer();
+  }
+
+  abstract homeFileName(): string;
+
+  fileBuilder(): FileContainer {
+    return this._fileContainer;
+  }
+
+  onBeforeProcess = (types: Type[]) => {
+    this._fileContainer.pushFile(new MarkdownHomeFile(this.homeFileName(), types));
+  };
+
+  onProcess(type: Type): void {
+    this._fileContainer.pushFile(new MarkdownTypeFile(type));
+  }
+}

package/src/transpiler/markdown/plain-markdown/plain-docsProcessor.ts

@@ -0,0 +1,12 @@
+import { MarkdownTranspilerBase } from '../markdown-transpiler-base';
+import { LinkingStrategy } from '../../processor-type-transpiler';
+
+export class PlainMarkdownDocsProcessor extends MarkdownTranspilerBase {
+  homeFileName(): string {
+    return 'index';
+  }
+
+  getLinkingStrategy(): LinkingStrategy {
+    return 'path-relative';
+  }
+}

package/src/{core → transpiler}/openapi/__tests__/open-api-docs-processor.spec.ts

@@ -1,5 +1,5 @@
 import { OpenApiDocsProcessor } from '../open-api-docs-processor';
-import { Settings } from '../../settings';
+import { Settings } from '../../../settings';
 import { SettingsBuilder } from '../../../test-helpers/SettingsBuilder';
 import { DocCommentBuilder } from '../../../test-helpers/DocCommentBuilder';
 import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';

package/src/{core → transpiler}/openapi/open-api-docs-processor.ts

@@ -1,17 +1,19 @@
-import { FileContainer } from './file-container';
+import ProcessorTypeTranspiler from '../processor-type-transpiler';
+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 { OpenapiTypeFile } from '../../model/openapi/openapi-type-file';
+import { Logger } from '../../util/logger';
+import { OpenApi } from '../../model/openapi/open-api';
+import { Settings } from '../../settings';
 import { MethodParser } from './parsers/MethodParser';
-import { camel2title } from '#utils/string-utils';
-import { createOpenApiFile } from './openapi-type-file';
+import { camel2title } from '../../util/string-utils';
 
-export class OpenApiDocsProcessor {
+export class OpenApiDocsProcessor extends ProcessorTypeTranspiler {
   protected readonly _fileContainer: FileContainer;
   openApiModel: OpenApi;
 
   constructor() {
+    super();
     this._fileContainer = new FileContainer();
     const title = Settings.getInstance().getOpenApiTitle();
     if (!title) {
@@ -66,8 +68,7 @@ export class OpenApiDocsProcessor {
   }
 
   onAfterProcess: ((types: Type[]) => void) | undefined = () => {
-    const page = createOpenApiFile(Settings.getInstance().openApiFileName(), this.openApiModel);
-    this._fileContainer.pushFile(page);
+    this._fileContainer.pushFile(new OpenapiTypeFile(this.openApiModel));
   };
 
   private getEndpointPath(type: Type): string | null {

package/src/{core → transpiler}/openapi/parsers/Builder.ts

@@ -1,6 +1,6 @@
 import { Reference, ReferenceBuilder } from './ReferenceBuilder';
-import { ApexDocSchemaObject } from '../../../core/openapi/apex-doc-types';
-import { SchemaObject } from '../../../core/openapi/open-api-types';
+import { ApexDocSchemaObject } from '../../../model/openapi/apex-doc-types';
+import { SchemaObject } from '../../../model/openapi/open-api-types';
 
 export type ApexDocSchemaAware = {
   schema: ApexDocSchemaObject;
@@ -29,7 +29,7 @@ export abstract class Builder<T, K> {
     return schemaAware.schema;
   }
 
-  private isReferenceString = (targetObject: unknown): targetObject is string => {
+  private isReferenceString = (targetObject: any): targetObject is string => {
     return typeof targetObject === 'string' || targetObject instanceof String;
   };
 }

package/src/{core → transpiler}/openapi/parsers/MethodParser.ts

@@ -1,7 +1,7 @@
 import { ClassMirror, MethodMirror } from '@cparra/apex-reflection';
-import { OpenApi } from '../../../core/openapi/open-api';
+import { OpenApi } from '../../../model/openapi/open-api';
 import * as yaml from 'js-yaml';
-import { ClassMirrorWrapper } from '../../../core/openapi/apex-type-wrappers/ClassMirrorWrapper';
+import { ClassMirrorWrapper } from '../../../model/apex-type-wrappers/ClassMirrorWrapper';
 import { Reference, ReferenceBuilder } from './ReferenceBuilder';
 import { ParameterObjectBuilder } from './ParameterObjectBuilder';
 import { ResponsesBuilder } from './ResponsesBuilder';
@@ -9,11 +9,11 @@ import {
   ApexDocHttpRequestBody,
   ApexDocHttpResponse,
   ApexDocParameterObject,
-} from '../../../core/openapi/apex-doc-types';
+} from '../../../model/openapi/apex-doc-types';
 import { RequestBodyBuilder } from './RequestBodyBuilder';
 import { ApexDocSchemaAware } from './Builder';
-import { PropertiesObject, ReferenceObject } from '../../../core/openapi/open-api-types';
-import { MethodMirrorWrapper } from '../../../core/openapi/apex-type-wrappers/MethodMirrorWrapper';
+import { PropertiesObject, ReferenceObject } from '../../../model/openapi/open-api-types';
+import { MethodMirrorWrapper } from '../../../model/apex-type-wrappers/MethodMirrorWrapper';
 
 type FallbackMethodParser = (methodMirror: MethodMirror) => void;
 type AddToOpenApi<T extends ApexDocSchemaAware> = (input: T, urlValue: string, httpMethodKey: HttpOperations) => void;
@@ -95,7 +95,7 @@ export class MethodParser {
 
     for (const annotation of annotations) {
       // We expect the ApexDoc data representing this to be in YAML format.
-      const inYaml = annotation?.bodyLines.reduce((prev, current) => prev + '\n' + current);
+      const inYaml = annotation?.bodyLines.reduce((prev, current, _) => prev + '\n' + current);
 
       if (!inYaml) {
         return;

package/src/{core → transpiler}/openapi/parsers/ParameterObjectBuilder.ts

@@ -1,6 +1,6 @@
-import { ParameterObject } from '../../../core/openapi/open-api-types';
+import { ParameterObject } from '../../../model/openapi/open-api-types';
 import { Reference } from './ReferenceBuilder';
-import { ApexDocParameterObject } from '../../../core/openapi/apex-doc-types';
+import { ApexDocParameterObject } from '../../../model/openapi/apex-doc-types';
 import { Builder } from './Builder';
 
 export class ParameterObjectBuilder extends Builder<ParameterObject, ApexDocParameterObject> {

package/src/{core → transpiler}/openapi/parsers/ReferenceBuilder.ts

@@ -5,11 +5,11 @@ import {
   SchemaObject,
   SchemaObjectArray,
   SchemaObjectObject,
-} from '../../../core/openapi/open-api-types';
-import { TypeBundle, TypesRepository } from '../../../core/openapi/types-repository';
+} from '../../../model/openapi/open-api-types';
+import { TypeBundle, TypesRepository } from '../../../model/types-repository';
 import { ClassMirror, DocCommentAnnotation, FieldMirror, PropertyMirror } from '@cparra/apex-reflection';
 import { ListObjectType, ReferencedType } from '@cparra/apex-reflection';
-import { ApexDocSchemaObject } from '../../../core/openapi/apex-doc-types';
+import { ApexDocSchemaObject } from '../../../model/openapi/apex-doc-types';
 
 type TypeBundleWithIsCollectionAndReferenceOverrides = TypeBundle & {
   originalTypeName: string;
@@ -131,7 +131,7 @@ export class ReferenceBuilder {
     referencedComponents: ReferenceComponent[],
   ) {
     // This can be of type ApexDocSchemaObject
-    const inYaml = manuallyDefinedHttpSchema?.bodyLines.reduce((prev, current) => prev + '\n' + current);
+    const inYaml = manuallyDefinedHttpSchema?.bodyLines.reduce((prev, current, _) => prev + '\n' + current);
     const asJson = yaml.load(inYaml) as ApexDocSchemaObject;
     const isReferenceString = this.isReferenceString(asJson);
 
@@ -227,7 +227,7 @@ export class ReferenceBuilder {
         return { schema: { type: 'object' }, referenceComponents: [] };
       case 'object':
         return { schema: { type: 'object' }, referenceComponents: [] };
-      default: {
+      default:
         // If we got here we are dealing with a non-primitive (most likely a custom class or an SObject).
         const referencedType = TypesRepository.getInstance().getFromAllByName(typeName);
         if (!referencedType) {
@@ -243,7 +243,6 @@ export class ReferenceBuilder {
           schema: reference.entrypointReferenceObject,
           referenceComponents: [...reference.referenceComponents],
         };
-      }
     }
   }
 
@@ -267,7 +266,7 @@ type SchemaObjectReferencePair = {
 
 class ReferenceOverrides {
   static build(referenceAsString: string): ReferenceOverride[] {
-    const cleanedUpReference = referenceAsString.replace(/[[\]]/g, '');
+    const cleanedUpReference = referenceAsString.replace(/[\[\]]/g, '');
     const referenceStrings = cleanedUpReference.split(',').map((item) => item.replace(/\s/g, ''));
     return referenceStrings.map((item) => {
       const [propertyName, referenceName] = item.split(':');