### Install @devlikeapro/n8n-openapi-node

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Install the n8n-openapi-node package as a dependency in your project using npm, pnpm, or yarn. This package contains the necessary tools to generate n8n node code from an OpenAPI specification.

```bash
npm install @devlikeapro/n8n-openapi-node
# OR
pnpm add @devlikeapro/n8n-openapi-node
# OR
yarn add @devlikeapro/n8n-openapi-node
```

--------------------------------

### Complete Petstore n8n Node Implementation

Source: https://context7.com/devlikeapro/n8n-openapi-node/llms.txt

Provides a full example of an n8n node for the Petstore API, integrating all components generated by N8NPropertiesBuilder. It includes custom field overrides and configures the node's metadata for n8n.

```typescript
import { INodeType, INodeTypeDescription, NodeConnectionType } from 'n8n-workflow';
import { N8NPropertiesBuilder, N8NPropertiesBuilderConfig, Override } from '@devlikeapro/n8n-openapi-node';
import * as doc from './petstore.json';

// Define custom overrides
const customOverrides: Override[] = [
  {
    find: { name: 'petId', type: 'number' },
    replace: { description: 'Pet ID from previous node', default: '={{ $json.petId }}' },
  },
];

// Build properties
const config: N8NPropertiesBuilderConfig = {};
const parser = new N8NPropertiesBuilder(doc, config);
const properties = parser.build(customOverrides);

export class Petstore implements INodeType {
  description: INodeTypeDescription = {
    displayName: 'Petstore',
    name: 'petstore',
    icon: 'file:petstore.svg',
    group: ['transform'],
    version: 1,
    subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
    description: 'Interact with Petstore API',
    defaults: {
      name: 'Petstore',
    },
    inputs: [NodeConnectionType.Main],
    outputs: [NodeConnectionType.Main],
    credentials: [
      {
        name: 'petstoreApi',
        required: false,
      },
    ],
    requestDefaults: {
      headers: {
        Accept: 'application/json',
        'Content-Type': 'application/json',
      },
      baseURL: '={{$credentials.url}}',
    },
    properties: properties,
  };
}

// Expected output includes:
// - Resource selector (Pet, Store, User)
// - Operations per resource (Create, Read, Update, Delete operations)
// - All parameters (path, query, body) with proper types and routing
// - Default values from examples
// - Enum fields converted to options

```

--------------------------------

### Custom Operation Parser for n8n

Source: https://context7.com/devlikeapro/n8n-openapi-node/llms.txt

Customize how OpenAPI operations are transformed into n8n actions using custom naming and filtering logic. This example extends the DefaultOperationParser to modify operation IDs, names, and descriptions.

```typescript
import { DefaultOperationParser, OperationContext, N8NPropertiesBuilder } from '@devlikeapro/n8n-openapi-node';
import { OpenAPIV3 } from 'openapi-types';
import * as lodash from 'lodash';
import * as doc from './openapi.json';

class CustomOperationParser extends DefaultOperationParser {
  shouldSkip(operation: OpenAPIV3.OperationObject, context: OperationContext): boolean {
    // Include deprecated operations
    return false;
  }

  name(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    // Handle NestJS-style operationIds: ControllerName_methodName
    if (operation.operationId) {
      const parts = operation.operationId.split('_');
      const methodName = parts.length > 1 ? parts.slice(1).join('_') : operation.operationId;
      return lodash.startCase(methodName);
    }
    return `${context.method.toUpperCase()} ${context.pattern}`;
  }

  value(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    const name = this.name(operation, context);
    return lodash.kebabCase(name);
  }

  action(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    // Prefer summary over description
    return operation.summary || operation.description || this.name(operation, context);
  }

  description(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    // Combine summary and description
    const parts = [];
    if (operation.summary) parts.push(operation.summary);
    if (operation.description && operation.description !== operation.summary) {
      parts.push(operation.description);
    }
    return parts.join(' - ') || '';
  }
}

const config = {
  operation: new CustomOperationParser()
};
const builder = new N8NPropertiesBuilder(doc, config);
const properties = builder.build();
```

--------------------------------

### Custom Resource Parsing with Default Override in TypeScript

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Extends the DefaultResourceParser to override specific methods for resource parsing. This example customizes the 'value' method to format the resource name. Dependencies include @devlikeapro/n8n-openapi-node, lodash, and openapi-types.

```typescript
import {OpenAPIV3} from 'openapi-types';
import * as lodash from 'lodash';
import {DefaultResourceParser} from '@devlikeapro/n8n-openapi-node';

export class CustomResourceParser extends DefaultResourceParser {
  value(tag: OpenAPIV3.TagObject): string {
    return lodash.startCase(tag.name.replace(/[^a-zA-Z0-9_-]/g, ''));
  }
}
```

--------------------------------

### Build n8n Properties with Custom Defaults using TypeScript

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Shows how to use the `N8NPropertiesBuilder` to generate n8n properties, incorporating custom field overrides. This example imports the necessary builder class, an OpenAPI document, and the previously defined custom defaults. The `build` method then processes these to create the final n8n properties configuration.

```typescript
import {N8NPropertiesBuilder, N8NPropertiesBuilderConfig} from '@devlikeapro/n8n-openapi-node';
import * as doc from './openapi.json';
import {customDefaults} from './customDefaults';

const parser = new N8NPropertiesBuilder(doc);
const properties = parser.build(customDefaults);
```

--------------------------------

### OpenAPIWalker with Custom Visitor for Document Traversal

Source: https://context7.com/devlikeapro/n8n-openapi-node/llms.txt

Traverse OpenAPI documents with custom visitors to extract specific information or perform custom processing. This example uses an EndpointCollector visitor to gather endpoint details.

```typescript
import { OpenAPIWalker, OpenAPIVisitor, OperationContext } from '@devlikeapro/n8n-openapi-node';
import { OpenAPIV3 } from 'openapi-types';
import * as doc from './openapi.json';

class EndpointCollector implements OpenAPIVisitor {
  endpoints: Array<{ method: string; path: string; summary?: string }> = [];

  visitOperation(operation: OpenAPIV3.OperationObject, context: OperationContext): void {
    this.endpoints.push({
      method: context.method.toUpperCase(),
      path: context.pattern,
      summary: operation.summary,
    });
  }

  visitTag(tag: OpenAPIV3.TagObject): void {
    console.log(`Found tag: ${tag.name} - ${tag.description}`);
  }

  finish(): void {
    console.log(`Total endpoints found: ${this.endpoints.length}`);
  }
}

const walker = new OpenAPIWalker(doc);
const collector = new EndpointCollector();
walker.walk(collector);

console.log('Collected endpoints:', collector.endpoints);
// Output: [
//   { method: 'GET', path: '/pets/{id}', summary: 'Get pet by ID' },
//   { method: 'POST', path: '/pets', summary: 'Create new pet' },
//   ...
// ]
```

--------------------------------

### Custom Operation Parsing with Default Override in TypeScript

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Extends the DefaultOperationParser to override specific methods for operation parsing. This example customizes the 'name' method to handle operation IDs with specific prefixes. Dependencies include @devlikeapro/n8n-openapi-node and lodash.

```typescript
import {DefaultOperationParser} from '@devlikeapro/n8n-openapi-node';

export class CustomOperationParser extends DefaultOperationParser {
  name(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    // NestJS add operationId in format CatController_findOne
    let operationId: string = operation.operationId!!.split('_').slice(1).join('_');
    if (!operationId) {
      operationId = operation.operationId as string;
    }
    return lodash.startCase(operationId);
  }
}
```

--------------------------------

### Field Value Overrides for n8n Properties

Source: https://context7.com/devlikeapro/n8n-openapi-node/llms.txt

Modify generated field properties using pattern matching to customize defaults, required status, or any property attribute. This example overrides specific fields like 'session', 'apiKey', and 'userId'.

```typescript
import { N8NPropertiesBuilder, Override } from '@devlikeapro/n8n-openapi-node';
import * as doc from './openapi.json';

const overrides: Override[] = [
  {
    // Override session field to use n8n expression
    find: {
      name: 'session',
      required: true,
      type: 'string',
    },
    replace: {
      default: '={{ $json.session }}',
    },
  },
  {
    // Change all optional API keys to required
    find: {
      name: 'apiKey',
      type: 'string',
    },
    replace: {
      required: true,
      default: '={{ $credentials.apiKey }}',
    },
  },
  {
    // Update description for all userId fields
    find: {
      name: 'userId',
    },
    replace: {
      description: 'The unique identifier of the user. Can be obtained from previous nodes.',
      default: '={{ $json.id }}',
    },
  },
];

const builder = new N8NPropertiesBuilder(doc);
const properties = builder.build(overrides);
```

--------------------------------

### Override Field Default Value in TypeScript

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Demonstrates how to define custom default values for fields in n8n nodes generated from OpenAPI specs. This example targets the 'session' field, changing its default from a string to a dynamic n8n expression. It utilizes the `Override` type from '@devlikeapro/n8n-openapi-node'.

```typescript
import {Override} from '@devlikeapro/n8n-openapi-node';

export const customDefaults: Override[] = [
  {
    // Find field by fields matching
    find: {
      name: 'session',
      required: true,
      type: 'string',
    },
    // Replace 'default' field value
    replace: {
      default: '={{ $json.session }}',
    },
  },
];
```

--------------------------------

### Configuring N8NPropertiesBuilder with Custom Resource Parser in TypeScript

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Demonstrates how to configure the N8NPropertiesBuilder with a custom resource parser. This involves creating a config object and passing it to the builder. Dependencies include @devlikeapro/n8n-openapi-node and a local openapi.json file.

```typescript
import {N8NPropertiesBuilder, N8NPropertiesBuilderConfig} from '@devlikeapro/n8n-openapi-node';
import * as doc from './openapi.json';

import {CustomResourceParser} from './CustomResourceParser';

const config: N8NPropertiesBuilderConfig = {
  resource: new CustomResourceParser()
}
const parser = new N8NPropertiesBuilder(doc, config);
const properties = parser.build()
```

--------------------------------

### Configuring N8NPropertiesBuilder with Custom Operation Parser in TypeScript

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Demonstrates how to configure the N8NPropertiesBuilder with a custom operation parser. This involves creating a config object and passing it to the builder. Dependencies include @devlikeapro/n8n-openapi-node and a local openapi.json file.

```typescript
import {N8NPropertiesBuilder, N8NPropertiesBuilderConfig} from '@devlikeapro/n8n-openapi-node';
import * as doc from './openapi.json';
import {CustomOperationParser} from './CustomOperationParser';

const config: N8NPropertiesBuilderConfig = {
  operation: new CustomOperationParser()
}
const parser = new N8NPropertiesBuilder(doc, config);
const properties = parser.build()
```

--------------------------------

### Generate n8n Node Properties from OpenAPI v3

Source: https://context7.com/devlikeapro/n8n-openapi-node/llms.txt

The N8NPropertiesBuilder.build() function is the primary entry point for converting an OpenAPI v3 document into an n8n node properties array. It takes the OpenAPI document and an optional configuration object. The output can be directly used in the 'properties' field of an n8n INodeTypeDescription.

```typescript
import { N8NPropertiesBuilder, N8NPropertiesBuilderConfig } from '@devlikeapro/n8n-openapi-node';
import * as doc from './openapi.json';

const config: N8NPropertiesBuilderConfig = {};
const builder = new N8NPropertiesBuilder(doc, config);
const properties = builder.build();

// Use in n8n node
export class MyNode implements INodeType {
  description: INodeTypeDescription = {
    displayName: 'My API',
    name: 'myApi',
    icon: 'file:myapi.svg',
    group: ['transform'],
    version: 1,
    subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
    description: 'Interact with My API',
    defaults: {
      name: 'My API',
    },
    inputs: [NodeConnectionType.Main],
    outputs: [NodeConnectionType.Main],
    credentials: [
      {
        name: 'myApiCredentials',
        required: false,
      },
    ],
    requestDefaults: {
      headers: {
        Accept: 'application/json',
        'Content-Type': 'application/json',
      },
      baseURL: '={{$credentials.url}}',
    },
    properties: properties, // Generated properties
  };
}
```

--------------------------------

### Customizing Operation Collection in n8n-openapi-node

Source: https://context7.com/devlikeapro/n8n-openapi-node/llms.txt

Demonstrates how to extend the BaseOperationsCollector to add custom fields, such as deprecation warnings, to operations. This allows for more detailed and context-aware operation definitions in n8n nodes. It utilizes pino for logging and OpenAPI specification parsing.

```typescript
import {
  N8NPropertiesBuilder,
  N8NPropertiesBuilderConfig,
  BaseOperationsCollector,
  ResourceCollector,
  DefaultOperationParser,
  DefaultResourceParser
} from '@devlikeapro/n8n-openapi-node';
import { OpenAPIV3 } from 'openapi-types';
import { OperationContext } from '@devlikeapro/n8n-openapi-node';
import pino from 'pino';
import * as doc from './openapi.json';

class CustomOperationsCollector extends BaseOperationsCollector {
  protected parseOperation(operation: OpenAPIV3.OperationObject, context: OperationContext) {
    const result = super.parseOperation(operation, context);

    // Add custom notice with endpoint and deprecation warning
    const warningText = operation.deprecated
      ? ' ⚠️ DEPRECATED'
      : '';
    const notice = {
      displayName: `${context.method.toUpperCase()} ${context.pattern}${warningText}`,
      name: 'operation',
      type: 'notice',
      typeOptions: {
        theme: operation.deprecated ? 'warning' : 'info',
      },
      default: '',
    };
    result.fields.unshift(notice);
    return result;
  }
}

const logger = pino({ level: 'info' });
const config: N8NPropertiesBuilderConfig = {
  logger: logger,
  OperationsCollector: CustomOperationsCollector,
  ResourcePropertiesCollector: ResourceCollector,
  operation: new DefaultOperationParser(),
  resource: new DefaultResourceParser(),
};

const builder = new N8NPropertiesBuilder(doc, config);
const properties = builder.build();

```

--------------------------------

### Custom Resource Parsing in TypeScript

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Defines a custom IResourceParser to control how resources are extracted from OpenAPI tags. It allows custom naming, value generation, and description retrieval. Dependencies include @devlikeapro/n8n-openapi-node and lodash.

```typescript
import {IResourceParser} from '@devlikeapro/n8n-openapi-node';

export class CustomResourceParser {
  CUSTOM_DESCRIPTION = {
    "cats": "Cats are cute",
  }

  name(tag: OpenAPIV3.TagObject): string {
    // Your custom logic here
    if (tag['X-Visible-Name']) {
      return tag['X-Visible-Name'];
    }
    return lodash.startCase(tag.name);
  }

  value(tag: Pick<OpenAPIV3.TagObject, "name">): string {
    // Remove all non-alphanumeric characters
    const name = tag.name.replace(/[^a-zA-Z0-9_-]/g, '')
    return lodash.startCase(name)
  }

  description(tag: OpenAPIV3.TagObject): string {
    // Your custom logic here
    return this.CUSTOM_DESCRIPTION[tag.name] || tag.description || '';
  }
}
```

--------------------------------

### Generate n8n Node Properties from OpenAPI v3 Spec (TypeScript)

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

This TypeScript code snippet demonstrates how to use the N8NPropertiesBuilder from @devlikeapro/n8n-openapi-node to generate n8n node properties. It imports the OpenAPI v3 spec, configures the builder, and then builds the properties which are assigned to the 'properties' field in the n8n INodeTypeDescription.

```typescript
import {INodeType, INodeTypeDescription, NodeConnectionType} from 'n8n-workflow';
import {N8NPropertiesBuilder, N8NPropertiesBuilderConfig} from '@devlikeapro/n8n-openapi-node';
import * as doc from './openapi.json'; // <=== Your OpenAPI v3 spec

const config: N8NPropertiesBuilderConfig = {}
const parser = new N8NPropertiesBuilder(doc, config);
const properties = parser.build()

export class Petstore implements INodeType {
  description: INodeTypeDescription = {
    displayName: 'Petstore',
    name: 'petstore',
    icon: 'file:petstore.svg',
    group: ['transform'],
    version: 1,
    subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
    description: 'Interact with Petstore API',
    defaults: {
      name: 'Petstore',
    },
    inputs: [NodeConnectionType.Main],
    outputs: [NodeConnectionType.Main],
    credentials: [
      {
        name: 'petstoreApi',
        required: false,
      },
    ],
    requestDefaults: {
      headers: {
        Accept: 'application/json',
        'Content-Type': 'application/json',
      },
      baseURL: '={{$credentials.url}}',
    },
    properties: properties, // <==== HERE
  };
}
```

--------------------------------

### Customize OpenAPI Resource Parsing with CustomResourceParser

Source: https://context7.com/devlikeapro/n8n-openapi-node/llms.txt

To override the default resource extraction logic, you can extend the DefaultResourceParser class and implement custom methods for 'name', 'value', and 'description'. This allows for tailored conversion of OpenAPI tags into n8n resources. The custom parser is then passed in the configuration object to N8NPropertiesBuilder.

```typescript
import { DefaultResourceParser, N8NPropertiesBuilder } from '@devlikeapro/n8n-openapi-node';
import { OpenAPIV3 } from 'openapi-types';
import * as lodash from 'lodash';
import * as doc from './openapi.json';

class CustomResourceParser extends DefaultResourceParser {
  name(tag: OpenAPIV3.TagObject): string {
    // Use custom X-Visible-Name if available
    if (tag['X-Visible-Name']) {
      return tag['X-Visible-Name'];
    }
    return lodash.startCase(tag.name);
  }

  value(tag: Pick<OpenAPIV3.TagObject, "name">): string {
    // Remove special characters for value
    const sanitized = tag.name.replace(/[^a-zA-Z0-9_-]/g, '');
    return lodash.camelCase(sanitized);
  }

  description(tag: OpenAPIV3.TagObject): string {
    // Add custom prefix to descriptions
    return `${tag.description || tag.name} - Custom resource`;
  }
}

const config = {
  resource: new CustomResourceParser()
};
const builder = new N8NPropertiesBuilder(doc, config);
const properties = builder.build();
```

--------------------------------

### Custom Operation Parsing in TypeScript

Source: https://github.com/devlikeapro/n8n-openapi-node/blob/main/README.md

Defines a custom IOperationParser to control how operations are extracted from OpenAPI operations. It allows skipping operations, custom naming, value generation, and defining action and description. Dependencies include @devlikeapro/n8n-openapi-node and lodash.

```typescript
import {IOperationParser} from '@devlikeapro/n8n-openapi-node';

export class CustomOperationParser implements IOperationParser {
  shouldSkip(operation: OpenAPIV3.OperationObject, context: OperationContext): boolean {
    // By default it skips operation.deprecated
    // But we can include all operations
    return false
  }

  name(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    if (operation['X-Visible-Name']) {
      return operation['X-Visible-Name'];
    }
    return lodash.startCase(operation.operationId)
  }

  value(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    return lodash.startCase(operation.operationId)
  }

  action(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    // How operation is displayed in n8n when you select your node (right form)
    return operation.summary || this.name(operation, context)
  }

  description(operation: OpenAPIV3.OperationObject, context: OperationContext): string {
    return operation.description || operation.summary || '';
  }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.