n8n-nodes-browser-smart-automation 0.1.2 → 0.1.5

package/nodes/McpClient/__test__/utils.test.ts

@@ -1,302 +0,0 @@
-import type { JSONSchema7Definition, JSONSchema7 } from 'json-schema';
-
-import {
-	convertJsonSchemaToResourceMapperFields,
-	jsonSchemaTypeToDefaultValue,
-	jsonSchemaTypeToFieldType,
-} from '../utils';
-
-describe('utils', () => {
-	describe('jsonSchemaTypeToFieldType', () => {
-		it.each([
-			[{ schema: { type: 'string', format: 'date-time' } as JSONSchema7, expected: 'dateTime' }],
-			[{ schema: { type: 'string' } as JSONSchema7, expected: 'string' }],
-			[{ schema: { type: 'number' } as JSONSchema7, expected: 'number' }],
-			[{ schema: { type: 'integer' } as JSONSchema7, expected: 'number' }],
-			[{ schema: { type: 'boolean' } as JSONSchema7, expected: 'boolean' }],
-			[{ schema: { type: 'array' } as JSONSchema7, expected: 'array' }],
-			[{ schema: { type: 'object' } as JSONSchema7, expected: 'object' }],
-		])('should return the correct field type for the schema', ({ schema, expected }) => {
-			expect(jsonSchemaTypeToFieldType(schema)).toEqual(expected);
-		});
-	});
-
-	describe('jsonSchemaTypeToDefaultValue', () => {
-		it.each([
-			[{ schema: false as JSONSchema7Definition, expected: null }],
-			[{ schema: true as JSONSchema7Definition, expected: 'any' }],
-			[{ schema: { type: 'string' } as JSONSchema7Definition, expected: 'string' }],
-			[{ schema: { type: 'number' } as JSONSchema7Definition, expected: 0 }],
-			[{ schema: { type: 'integer' } as JSONSchema7Definition, expected: 0 }],
-			[{ schema: { type: 'number', minimum: -1 } as JSONSchema7Definition, expected: -1 }],
-			[{ schema: { type: 'number', maximum: 1 } as JSONSchema7Definition, expected: 1 }],
-			[{ schema: { type: 'boolean' } as JSONSchema7Definition, expected: false }],
-			[
-				{
-					schema: { type: 'string', format: 'date-time' } as JSONSchema7Definition,
-					expected: '2025-01-01T00:00:00Z',
-				},
-			],
-			[
-				{
-					schema: { type: 'string', format: 'uri' } as JSONSchema7Definition,
-					expected: 'https://example.com',
-				},
-			],
-			[
-				{
-					schema: { type: 'string', format: 'url' } as JSONSchema7Definition,
-					expected: 'https://example.com',
-				},
-			],
-			[
-				{
-					schema: { type: 'string', format: 'date' } as JSONSchema7Definition,
-					expected: '2025-01-01',
-				},
-			],
-			[
-				{
-					schema: { type: 'string', format: 'time' } as JSONSchema7Definition,
-					expected: '00:00:00',
-				},
-			],
-			[{ schema: { type: 'array' } as JSONSchema7Definition, expected: [] }],
-			[
-				{
-					schema: { type: 'array', items: { type: 'string' } } as JSONSchema7Definition,
-					expected: ['string'],
-				},
-			],
-			[
-				{
-					schema: {
-						type: 'array',
-						items: [{ type: 'number' }, { type: 'string' }],
-					} as JSONSchema7Definition,
-					expected: [0, 'string'],
-				},
-			],
-			[
-				{
-					schema: {
-						type: 'object',
-						properties: {
-							name: { type: 'string' },
-							age: { type: 'number' },
-						},
-						required: ['name', 'age'],
-						additionalProperties: false,
-					} as JSONSchema7Definition,
-					expected: { name: 'string', age: 0 },
-				},
-			],
-			[
-				{
-					schema: {
-						type: 'object',
-						properties: {
-							name: { type: 'string' },
-							age: { type: 'number' },
-						},
-						required: ['name', 'age'],
-						additionalProperties: { type: 'string' },
-					} as JSONSchema7Definition,
-					expected: { name: 'string', age: 0, '<additionalProperty>': 'string' },
-				},
-			],
-			[
-				{
-					schema: {
-						type: 'string',
-						enum: ['foo', 'bar'],
-					} as JSONSchema7Definition,
-					expected: 'foo',
-				},
-			],
-			[
-				{
-					schema: {
-						oneOf: [{ type: 'string' }, { type: 'number' }],
-					} as JSONSchema7Definition,
-					expected: 'string',
-				},
-			],
-			[
-				{
-					schema: {
-						anyOf: [{ type: 'string' }, { type: 'number' }],
-					} as JSONSchema7Definition,
-					expected: 'string',
-				},
-			],
-			[
-				{
-					schema: {
-						allOf: [
-							{
-								type: 'object',
-								properties: {
-									age: { type: 'number' },
-								},
-								required: ['age'],
-								additionalProperties: false,
-							},
-							{
-								type: 'object',
-								properties: {
-									name: { type: 'string' },
-								},
-								required: ['name'],
-								additionalProperties: false,
-							},
-						],
-					} as JSONSchema7Definition,
-					expected: { age: 0, name: 'string' },
-				},
-			],
-		])('should return the correct default value for the schema', ({ schema, expected }) => {
-			expect(jsonSchemaTypeToDefaultValue(schema)).toEqual(expected);
-		});
-	});
-
-	describe('convertJsonSchemaToResourceMapperFields', () => {
-		it.each([
-			[
-				{
-					schema: { type: 'string' } as JSONSchema7,
-					expected: [],
-				},
-			],
-			[
-				{
-					schema: { type: 'object' } as JSONSchema7,
-					expected: [],
-				},
-			],
-			[
-				{
-					schema: {
-						type: 'object',
-						properties: { name: { type: 'string' }, age: { type: 'number' } },
-						required: ['name'],
-					} as JSONSchema7,
-					expected: [
-						{
-							id: 'name',
-							displayName: 'name',
-							defaultMatch: false,
-							required: true,
-							display: true,
-							type: 'string',
-						},
-						{
-							id: 'age',
-							displayName: 'age',
-							defaultMatch: false,
-							required: false,
-							display: true,
-							type: 'number',
-						},
-					],
-				},
-			],
-			[
-				{
-					schema: { type: 'object', properties: { name: true, age: false } } as JSONSchema7,
-					expected: [
-						{
-							id: 'name',
-							displayName: 'name',
-							defaultMatch: false,
-							required: false,
-							display: true,
-							type: 'string',
-						},
-					],
-				},
-			],
-		])(
-			'should return the correct resource mapper fields for the schema',
-			({ schema, expected }) => {
-				expect(convertJsonSchemaToResourceMapperFields(schema)).toEqual(expected);
-			},
-		);
-
-		it.each([
-			[
-				{
-					schema: {
-						type: 'object',
-						properties: { names: { type: 'array', items: { type: 'string' } } },
-						required: ['names'],
-					} as JSONSchema7,
-					expected: [
-						{
-							id: 'names',
-							displayName: 'names',
-							defaultMatch: false,
-							required: true,
-							display: true,
-							type: 'array',
-							defaultValue: JSON.stringify(['string'], null, 2),
-						},
-					],
-				},
-			],
-			[
-				{
-					schema: {
-						type: 'object',
-						properties: {
-							user: {
-								type: 'object',
-								properties: { name: { type: 'string' }, age: { type: 'number' } },
-							},
-						},
-						required: ['user'],
-					} as JSONSchema7,
-					expected: [
-						{
-							id: 'user',
-							displayName: 'user',
-							defaultMatch: false,
-							required: true,
-							display: true,
-							type: 'object',
-							defaultValue: JSON.stringify({ name: 'string', age: 0 }, null, 2),
-						},
-					],
-				},
-			],
-		])('should add defaultValue for arrays and objects', ({ schema, expected }) => {
-			expect(convertJsonSchemaToResourceMapperFields(schema)).toEqual(expected);
-		});
-
-		it('should add options for enums', () => {
-			const schema = {
-				type: 'object',
-				properties: { color: { type: 'string', enum: ['red', 'green', 'blue'] } },
-			} as JSONSchema7;
-			const expected = [
-				{
-					id: 'color',
-					displayName: 'color',
-					defaultMatch: false,
-					required: false,
-					display: true,
-					type: 'options',
-					options: [
-						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
-						{ name: 'red', value: 'red' },
-						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
-						{ name: 'green', value: 'green' },
-						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
-						{ name: 'blue', value: 'blue' },
-					],
-				},
-			];
-			expect(convertJsonSchemaToResourceMapperFields(schema)).toEqual(expected);
-		});
-	});
-});

package/nodes/McpClient/listSearch.ts

@@ -1,48 +0,0 @@
-import type { ILoadOptionsFunctions, INodeListSearchResult } from 'n8n-workflow';
-
-import type { McpAuthenticationOption, McpServerTransport } from '../shared/types';
-import {
-	connectMcpClient,
-	getAuthHeaders,
-	mapToNodeOperationError,
-	tryRefreshOAuth2Token,
-} from '../shared/utils';
-
-export async function getTools(
-	this: ILoadOptionsFunctions,
-	filter?: string,
-	paginationToken?: string,
-): Promise<INodeListSearchResult> {
-	const authentication = this.getNodeParameter('authentication') as McpAuthenticationOption;
-	const serverTransport = this.getNodeParameter('serverTransport') as McpServerTransport;
-	const endpointUrl = this.getNodeParameter('endpointUrl') as string;
-	const node = this.getNode();
-	const { headers } = await getAuthHeaders(this, authentication);
-	const client = await connectMcpClient({
-		serverTransport,
-		endpointUrl,
-		headers,
-		name: node.type,
-		version: node.typeVersion,
-		onUnauthorized: async (headers) => await tryRefreshOAuth2Token(this, authentication, headers),
-	});
-
-	if (!client.ok) {
-		throw mapToNodeOperationError(node, client.error);
-	}
-
-	const result = await client.result.listTools({ cursor: paginationToken });
-	const tools = filter
-		? result.tools.filter((tool) => tool.name.toLowerCase().includes(filter.toLowerCase()))
-		: result.tools;
-
-	return {
-		results: tools.map((tool) => ({
-			name: tool.name,
-			value: tool.name,
-			description: tool.description,
-			inputSchema: tool.inputSchema,
-		})),
-		paginationToken: result.nextCursor,
-	};
-}

package/nodes/McpClient/resourceMapping.ts

@@ -1,48 +0,0 @@
-import type { ILoadOptionsFunctions, ResourceMapperFields } from 'n8n-workflow';
-import { NodeOperationError } from 'n8n-workflow';
-
-import { convertJsonSchemaToResourceMapperFields } from './utils';
-import type { McpAuthenticationOption, McpServerTransport } from '../shared/types';
-import {
-	getAuthHeaders,
-	connectMcpClient,
-	getAllTools,
-	tryRefreshOAuth2Token,
-	mapToNodeOperationError,
-} from '../shared/utils';
-
-export async function getToolParameters(
-	this: ILoadOptionsFunctions,
-): Promise<ResourceMapperFields> {
-	const toolId = this.getNodeParameter('tool', 0, {
-		extractValue: true,
-	}) as string;
-	const authentication = this.getNodeParameter('authentication') as McpAuthenticationOption;
-	const serverTransport = this.getNodeParameter('serverTransport') as McpServerTransport;
-	const endpointUrl = this.getNodeParameter('endpointUrl') as string;
-	const node = this.getNode();
-	const { headers } = await getAuthHeaders(this, authentication);
-	const client = await connectMcpClient({
-		serverTransport,
-		endpointUrl,
-		headers,
-		name: node.type,
-		version: node.typeVersion,
-		onUnauthorized: async (headers) => await tryRefreshOAuth2Token(this, authentication, headers),
-	});
-
-	if (!client.ok) {
-		throw mapToNodeOperationError(node, client.error);
-	}
-
-	const result = await getAllTools(client.result);
-	const tool = result.find((tool) => tool.name === toolId);
-	if (!tool) {
-		throw new NodeOperationError(this.getNode(), 'Tool not found');
-	}
-
-	const fields = convertJsonSchemaToResourceMapperFields(tool.inputSchema);
-	return {
-		fields,
-	};
-}

package/nodes/McpClient/utils.ts

@@ -1,281 +0,0 @@
-import type { JSONSchema7, JSONSchema7Definition } from 'json-schema';
-import type {
-	ResourceMapperField,
-	FieldType,
-	INodePropertyOptions,
-	IDataObject,
-} from 'n8n-workflow';
-
-function pickFirstSchema(schema: JSONSchema7Definition): JSONSchema7Definition {
-	if (typeof schema === 'object' && (schema?.anyOf || schema?.oneOf)) {
-		if (Array.isArray(schema.anyOf) && schema.anyOf[0] !== undefined) {
-			return schema.anyOf[0];
-		}
-
-		if (Array.isArray(schema.oneOf) && schema.oneOf[0] !== undefined) {
-			return schema.oneOf[0];
-		}
-	}
-
-	return schema;
-}
-
-function mergeTwoSchemas(
-	a?: JSONSchema7Definition,
-	b?: JSONSchema7Definition,
-): JSONSchema7Definition | undefined {
-	if (a === undefined) {
-		return b;
-	}
-
-	if (b === undefined) {
-		return a;
-	}
-
-	a = pickFirstSchema(a);
-	b = pickFirstSchema(b);
-	if (a === false || b === false) {
-		return false;
-	}
-
-	if (a === true || b === true) {
-		return true;
-	}
-
-	if (a.type === 'object' && b.type === 'object') {
-		const properties = { ...(a.properties ?? {}), ...(b.properties ?? {}) };
-		const required = [...(a.required ?? []), ...(b.required ?? [])];
-		const additionalProperties = mergeTwoSchemas(a.additionalProperties, b.additionalProperties);
-		return { ...a, ...b, properties, required, additionalProperties };
-	}
-
-	if (a.type === 'array' && b.type === 'array') {
-		if (Array.isArray(a.items) && Array.isArray(b.items)) {
-			// Two tuples -> pick the longer one
-			return a.items.length > b.items.length ? a : b;
-		}
-
-		if (Array.isArray(a.items) || Array.isArray(b.items)) {
-			// One tuple -> pick the tuple
-			return Array.isArray(a.items) ? a : b;
-		}
-
-		const items = mergeTwoSchemas(a.items, b.items);
-		return { ...a, ...b, items };
-	}
-
-	return undefined;
-}
-
-function mergeAllOfSchemas(schemas: JSONSchema7Definition[]): JSONSchema7Definition | undefined {
-	if (schemas.length === 0) {
-		return undefined;
-	}
-
-	if (schemas.length === 1) {
-		return schemas[0];
-	}
-
-	return schemas.reduce(
-		(acc, schema) => mergeTwoSchemas(acc, schema),
-		undefined as JSONSchema7Definition | undefined,
-	);
-}
-
-export function jsonSchemaTypeToDefaultValue(
-	schema: JSONSchema7Definition,
-): string | number | boolean | object | null {
-	if (schema === false) {
-		return null;
-	}
-
-	if (schema === true) {
-		return 'any';
-	}
-
-	if (schema.allOf) {
-		const mergedSchema = mergeAllOfSchemas(schema.allOf);
-		if (mergedSchema !== undefined) {
-			return jsonSchemaTypeToDefaultValue(mergedSchema);
-		}
-	}
-
-	if (schema.anyOf) {
-		const anyOfSchemas = schema.anyOf;
-		for (const anyOfSchema of anyOfSchemas) {
-			const defaultValue = jsonSchemaTypeToDefaultValue(anyOfSchema);
-			if (defaultValue !== null) {
-				return defaultValue;
-			}
-		}
-	}
-
-	if (schema.oneOf) {
-		const oneOfSchemas = schema.oneOf;
-		for (const oneOfSchema of oneOfSchemas) {
-			const defaultValue = jsonSchemaTypeToDefaultValue(oneOfSchema);
-			if (defaultValue !== null) {
-				return defaultValue;
-			}
-		}
-	}
-
-	if (schema.enum && Array.isArray(schema.enum)) {
-		return schema.enum[0];
-	}
-
-	if (Array.isArray(schema.type)) {
-		const types = schema.type;
-		for (const type of types) {
-			const defaultValue = jsonSchemaTypeToDefaultValue({ type });
-			if (defaultValue !== null) {
-				return defaultValue;
-			}
-		}
-	}
-
-	if (schema.type === 'number' || schema.type === 'integer') {
-		if (schema.minimum !== undefined) {
-			return schema.minimum;
-		}
-
-		if (schema.maximum !== undefined) {
-			return schema.maximum;
-		}
-
-		return 0;
-	}
-
-	if (schema.type === 'boolean') {
-		return false;
-	}
-
-	if (schema.type === 'string') {
-		if (schema.format === 'date-time') {
-			return '2025-01-01T00:00:00Z';
-		}
-
-		if (schema.format === 'uri' || schema.format === 'url') {
-			return 'https://example.com';
-		}
-
-		if (schema.format === 'date') {
-			return '2025-01-01';
-		}
-
-		if (schema.format === 'time') {
-			return '00:00:00';
-		}
-
-		return 'string';
-	}
-
-	if (schema.type === 'array') {
-		if (!schema.items) {
-			return [];
-		}
-
-		if (Array.isArray(schema.items)) {
-			return schema.items.map((item) => jsonSchemaTypeToDefaultValue(item));
-		}
-
-		return [jsonSchemaTypeToDefaultValue(schema.items)];
-	}
-
-	if (schema.type === 'object') {
-		const properties = schema.properties ?? {};
-		const exampleObject: IDataObject = {};
-		for (const [key, propertySchema] of Object.entries(properties)) {
-			const propertyValue = jsonSchemaTypeToDefaultValue(propertySchema);
-			if (propertyValue !== null) {
-				exampleObject[key] = propertyValue;
-			}
-		}
-
-		if (schema.additionalProperties) {
-			const additionalProperties = jsonSchemaTypeToDefaultValue(schema.additionalProperties);
-			if (additionalProperties !== null) {
-				exampleObject['<additionalProperty>'] = additionalProperties;
-			}
-		}
-
-		return exampleObject;
-	}
-
-	return null;
-}
-
-export function jsonSchemaTypeToFieldType(schema: JSONSchema7): FieldType {
-	if (schema.type === 'string' && schema.format === 'date-time') {
-		return 'dateTime';
-	}
-
-	if (schema.type === 'number' || schema.type === 'integer') {
-		return 'number';
-	}
-
-	if (schema.type === 'boolean' || schema.type === 'array' || schema.type === 'object') {
-		return schema.type;
-	}
-
-	return 'string';
-}
-
-export function convertJsonSchemaToResourceMapperFields(
-	schema: JSONSchema7,
-): ResourceMapperField[] {
-	const fields: ResourceMapperField[] = [];
-	if (schema.type !== 'object' || !schema.properties) {
-		return fields;
-	}
-
-	const required = Array.isArray(schema.required) ? schema.required : [];
-	for (const [key, propertySchema] of Object.entries(schema.properties)) {
-		if (propertySchema === false) {
-			continue;
-		}
-
-		if (propertySchema === true) {
-			fields.push({
-				id: key,
-				displayName: key,
-				defaultMatch: false,
-				required: required.includes(key),
-				display: true,
-				type: 'string', // use string as a "catch all" for any values
-			});
-			continue;
-		}
-
-		const schemaType = jsonSchemaTypeToFieldType(propertySchema);
-		let defaultValue: string | undefined;
-		if (schemaType === 'object' || schemaType === 'array') {
-			const result = jsonSchemaTypeToDefaultValue(propertySchema);
-			if (result !== null) {
-				defaultValue = JSON.stringify(result, null, 2);
-			}
-		}
-
-		const field: ResourceMapperField = {
-			id: key,
-			displayName: propertySchema.title ?? key,
-			defaultMatch: false,
-			required: required.includes(key),
-			display: true,
-			type: schemaType,
-			defaultValue,
-		};
-
-		if (propertySchema.enum && Array.isArray(propertySchema.enum)) {
-			field.type = 'options';
-			field.options = propertySchema.enum.map((value) => ({
-				name: value,
-				value,
-			})) as INodePropertyOptions[];
-		}
-
-		fields.push(field);
-	}
-
-	return fields;
-}