Parsers

Author: devlikepro

ResourceParser.ts

@@ -0,0 +1,27 @@
+import {OpenAPIV3} from "openapi-types";
+import * as lodash from "lodash";
+import {toResourceName} from "./src/n8n/utils";
+
+export interface IResourceParser {
+    name(tag: OpenAPIV3.TagObject): string
+
+    value(tag: Pick<OpenAPIV3.TagObject, "name">): string
+
+    description(tag: OpenAPIV3.TagObject): string
+}
+
+export class DefaultResourceParser {
+    name(tag: OpenAPIV3.TagObject): string {
+        return lodash.startCase(tag.name);
+    }
+
+    value(tag: Pick<OpenAPIV3.TagObject, "name">): string {
+        // TODO: use startCase by default
+        return toResourceName(tag.name)
+        // return lodash.startCase(tag.name);
+    }
+
+    description(tag: OpenAPIV3.TagObject): string {
+        return tag.description || '';
+    }
+}

src/N8NPropertiesBuilder.spec.ts

@@ -630,10 +630,9 @@ test('test overrides', () => {
     ];
 
     const parser = new N8NPropertiesBuilder({paths, components}, {
-        overrides: customDefaults,
         OperationsCollector: BaseOperationsCollector
     });
-    const result = parser.build()
+    const result = parser.build(customDefaults)
 
     expect(result).toEqual([
         {

src/N8NPropertiesBuilder.ts

@@ -2,9 +2,11 @@ import {INodeProperties} from 'n8n-workflow';
 import {OpenAPIV3} from 'openapi-types';
 import pino from 'pino';
 import {OpenAPIWalker} from "./openapi/OpenAPIWalker";
-import {ResourcePropertiesCollector as ResourcePropertiesCollectorImpl} from "./ResourcePropertiesCollector";
+import {ResourceCollector as ResourcePropertiesCollector} from "./ResourceCollector";
 import {BaseOperationsCollector, OperationsCollector as OperationsCollectorImpl} from "./OperationsCollector";
 import * as lodash from "lodash";
+import {DefaultOperationParser, IOperationParser} from "./OperationParser";
+import {DefaultResourceParser, IResourceParser} from "../ResourceParser";
 
 export interface Override {
     find: any;
@@ -13,42 +15,52 @@ export interface Override {
 
 export interface N8NPropertiesBuilderConfig {
     logger?: pino.Logger;
-    overrides?: Override[];
     OperationsCollector?: typeof BaseOperationsCollector,
-    ResourcePropertiesCollector?: typeof ResourcePropertiesCollectorImpl
+    ResourcePropertiesCollector?: typeof ResourcePropertiesCollector
+    operation?: IOperationParser,
+    resource?: IResourceParser,
 }
 
 export class N8NPropertiesBuilder {
     private readonly doc: OpenAPIV3.Document;
     private readonly logger: pino.Logger
     private readonly walker: OpenAPIWalker;
-    private readonly overrides: Override[]
 
     // DI
+    private readonly operationParser: IOperationParser;
+    private readonly resourceParser: IResourceParser;
     private readonly OperationsCollector: typeof BaseOperationsCollector;
-    private readonly ResourcePropertiesCollector: typeof ResourcePropertiesCollectorImpl;
+    private readonly ResourcePropertiesCollector: typeof ResourcePropertiesCollector;
 
     constructor(doc: any, config?: N8NPropertiesBuilderConfig) {
         this.doc = doc
         this.logger = config?.logger || pino({transport: {target: 'pino-pretty'}})
         this.walker = new OpenAPIWalker(this.doc)
+
+        // DI
+        this.operationParser = config?.operation || new DefaultOperationParser()
+        this.resourceParser = config?.resource || new DefaultResourceParser()
         this.OperationsCollector = config?.OperationsCollector ? config.OperationsCollector : OperationsCollectorImpl
-        this.ResourcePropertiesCollector = config?.ResourcePropertiesCollector ? config.ResourcePropertiesCollector : ResourcePropertiesCollectorImpl
-        this.overrides = config?.overrides || []
+        this.ResourcePropertiesCollector = config?.ResourcePropertiesCollector ? config.ResourcePropertiesCollector : ResourcePropertiesCollector
     }
 
-    build(): INodeProperties[] {
-        const resourcePropertiesCollector = new this.ResourcePropertiesCollector()
+    build(overrides: Override[] = []): INodeProperties[] {
+        const resourcePropertiesCollector = new this.ResourcePropertiesCollector(this.resourceParser)
         this.walker.walk(resourcePropertiesCollector)
-        const resourceNode = resourcePropertiesCollector.iNodeProperty
+        const resourceNode = resourcePropertiesCollector.resources
 
-        const operationsCollector = new this.OperationsCollector(this.logger, this.doc)
+        const operationsCollector = new this.OperationsCollector(
+            this.doc,
+            this.operationParser,
+            this.resourceParser,
+            this.logger,
+        )
         this.walker.walk(operationsCollector)
         const operations = operationsCollector.operations
         const fields = operationsCollector.fields
 
         const properties = [resourceNode, ...operations, ...fields]
-        return this.update(properties, this.overrides)
+        return this.update(properties, overrides)
     }
 
     private update(fields: any[], patterns: Override[]) {

src/OperationParser.ts

@@ -32,5 +32,4 @@ export class DefaultOperationParser implements IOperationParser {
     description(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
         return operation.description || operation.summary || '';
     }
-
 }

src/OperationsCollector.ts

@@ -3,25 +3,26 @@ import * as lodash from "lodash";
 import pino from "pino";
 import {OpenAPIV3} from "openapi-types";
 import {N8NINodeProperties} from "./SchemaToINodeProperties";
-import {DefaultOperationParser, IOperationParser} from "./OperationParser";
+import {IOperationParser} from "./OperationParser";
 import {OptionsByResourceMap} from "./n8n/OptionsByResourceMap";
 import {INodeProperties} from "n8n-workflow";
 import {replacePathVarsToParameter} from "./n8n/utils";
-import {DefaultResourceParser, IResourceParser} from "../ResourceParser";
+import {IResourceParser} from "../ResourceParser";
 
 export class BaseOperationsCollector implements OpenAPIVisitor {
     public readonly _fields: INodeProperties[]
     private optionsByResource: OptionsByResourceMap = new OptionsByResourceMap()
-    private readonly logger: pino.Logger;
     private n8nNodeProperties: N8NINodeProperties;
 
-    // Dependency injection light version
-    protected operationParser: IOperationParser = new DefaultOperationParser()
-    protected resourceParser: IResourceParser = new DefaultResourceParser()
+    // Log context
     private bindings: any
 
-    constructor(logger: pino.Logger, doc: any) {
-        this.logger = logger.child({})
+    constructor(
+        doc: any,
+        protected operationParser: IOperationParser,
+        protected resourceParser: IResourceParser,
+        protected logger: pino.Logger
+    ) {
         this._fields = []
         this.n8nNodeProperties = new N8NINodeProperties(doc)
     }

src/ResourcePropertiesCollector.ts src/ResourceCollector.tssrc/ResourcePropertiesCollector.ts renamed to src/ResourceCollector.ts

@@ -1,7 +1,7 @@
 import {OpenAPIVisitor, OperationContext} from "./openapi/OpenAPIVisitor";
 import {OpenAPIV3} from "openapi-types";
 import {INodeProperties} from "n8n-workflow";
-import {DefaultResourceParser, IResourceParser} from "../ResourceParser";
+import {IResourceParser} from "../ResourceParser";
 
 interface TagObject {
     name: string;
@@ -12,16 +12,15 @@ interface TagObject {
  * Collects resource properties from OpenAPI document
  * Resource is basically tags from OpenAPI spec
  */
-export class ResourcePropertiesCollector implements OpenAPIVisitor {
+export class ResourceCollector implements OpenAPIVisitor {
     private tags: Map<string, TagObject>;
     private tagsOrder = new Map<string, number>();
-    protected resourceParser: IResourceParser = new DefaultResourceParser()
 
-    constructor() {
+    constructor(protected resourceParser: IResourceParser) {
         this.tags = new Map<string, TagObject>()
     }
 
-    get iNodeProperty(): INodeProperties {
+    get resources(): INodeProperties {
         const tags = this.sortedTags
         const parser = this.resourceParser
         const options = tags.map((tag) => {