fix: package review fixes (#20)

* fix: dep and item pairing fix

* fix: coding standard and continueOnFail

* fix: n8n-core peer dep for tests

* chore: remove old testing file

* feat: mocked tests without n8n-core

* fix: formatting fixes

* fix: remove n8n-core

Author: protoss70

nodes/ApifyContentCrawler/ApifyContentCrawler.node.ts

@@ -60,17 +60,33 @@ export class ApifyContentCrawler implements INodeType {
 
 	methods = methods;
 
-	async execute(this: IExecuteFunctions) {
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
 		const items = this.getInputData();
 		const returnData: INodeExecutionData[] = [];
 
 		for (let i = 0; i < items.length; i++) {
-			const data = await actorsRouter.call(this, i);
-			// `data` may be an array of items or a single item, so we either push the spreaded array or the single item
-			if (Array.isArray(data)) {
-				returnData.push(...data);
-			} else {
-				returnData.push(data);
+			try {
+				const data = await actorsRouter.call(this, i);
+
+				const addPairedItem = (item: INodeExecutionData) => ({
+					...item,
+					pairedItem: { item: i },
+				});
+
+				if (Array.isArray(data)) {
+					returnData.push(...data.map(addPairedItem));
+				} else {
+					returnData.push(addPairedItem(data));
+				}
+			} catch (error) {
+				if (this.continueOnFail()) {
+					returnData.push({
+						json: { error: error.message },
+						pairedItem: { item: i },
+					});
+					continue;
+				}
+				throw error;
 			}
 		}
 

nodes/ApifyContentCrawler/__tests__/Apify.node.spec.ts

@@ -1,8 +1,7 @@
-import { ACTOR_ID, ApifyContentCrawler } from '../ApifyContentCrawler.node';
+import { ApifyContentCrawler } from '../ApifyContentCrawler.node';
 import { executeWorkflow } from './utils/executeWorkflow';
 import { CredentialsHelper } from './utils/credentialHelper';
 import { getRunTaskDataByNodeName, getTaskData } from './utils/getNodeResultData';
-import nock from 'nock';
 import * as fixtures from './utils/fixtures';
 
 describe('Apify Node', () => {
@@ -36,9 +35,6 @@ describe('Apify Node', () => {
 
 	describe('actors', () => {
 		describe('run-actor', () => {
-			const mockRunActor = fixtures.runActorResult();
-			const mockBuild = fixtures.getBuildResult();
-			const mockFinishedRun = fixtures.getSuccessRunResult();
 			const mockResultDataset = fixtures.getDatasetItems();
 
 			const tests = [
@@ -52,17 +48,6 @@ describe('Apify Node', () => {
 			test.each(tests)(
 				'$name should run the WCC actor correctly',
 				async ({ workflowJsonName, nodeName }) => {
-					const scope = nock('https://api.apify.com')
-						.get(`/v2/acts/${ACTOR_ID}/builds/default`)
-						.reply(200, mockBuild)
-						.post(`/v2/acts/${ACTOR_ID}/runs`)
-						.query({ waitForFinish: 0 })
-						.reply(200, mockRunActor)
-						.get('/v2/actor-runs/5rsC83CHinQwPlsSI')
-						.reply(200, mockFinishedRun)
-						.get('/v2/datasets/63kMAihbWVgBvEAZ2/items')
-						.reply(200, mockResultDataset);
-
 					const workflow = require(`./workflows/actors/${workflowJsonName}`);
 					const { executionData } = await executeWorkflow({
 						credentialsHelper,
@@ -79,9 +64,6 @@ describe('Apify Node', () => {
 					expect(typeof data).toBe('object');
 
 					expect(data).toEqual(mockResultDataset[0]);
-
-					console.log(`Pending mocks for ${workflowJsonName}:`, scope.pendingMocks());
-					expect(scope.isDone()).toBe(true);
 				},
 			);
 		});

nodes/ApifyContentCrawler/__tests__/utils/credentialHelper.ts

@@ -1,30 +1,33 @@
-import { Credentials } from 'n8n-core';
+// utils/credentialHelper.ts
 import {
 	ICredentialDataDecryptedObject,
 	ICredentialsHelper,
-	IHttpRequestHelper,
+	INodeProperties,
 	IHttpRequestOptions,
+	IHttpRequestHelper,
+	IRequestOptionsSimplified,
 	INode,
-	INodeCredentialsDetails,
-	ICredentials,
-	INodeProperties,
-	IWorkflowExecuteAdditionalData,
-	WorkflowExecuteMode,
-	IExecuteData,
-	ICredentialsExpressionResolveValues,
 	Workflow,
-	IRequestOptionsSimplified,
 } from 'n8n-workflow';
 
-export class CredentialsHelper extends ICredentialsHelper {
-	private credentials: Record<string, ICredentialDataDecryptedObject>;
+export class CredentialsHelper implements ICredentialsHelper {
+	constructor(private credentials: Record<string, ICredentialDataDecryptedObject>) {}
 
-	constructor(credentials: Record<string, ICredentialDataDecryptedObject>) {
-		super();
-		this.credentials = credentials;
+	getParentTypes(name: string): string[] {
+		return [];
 	}
 
-	getParentTypes(name: string): string[] {
+	async getDecrypted(): Promise<ICredentialDataDecryptedObject> {
+		return this.credentials['apifyApi'];
+	}
+
+	async getCredentials(): Promise<any> {
+		return {};
+	}
+
+	async updateCredentials(): Promise<void> {}
+
+	getCredentialsProperties(type: string): INodeProperties[] {
 		return [];
 	}
 
@@ -35,6 +38,7 @@ export class CredentialsHelper extends ICredentialsHelper {
 		workflow: Workflow,
 		node: INode,
 	): Promise<IHttpRequestOptions> {
+		// For testing, just return requestOptions as-is
 		return requestOptions as IHttpRequestOptions;
 	}
 
@@ -47,33 +51,4 @@ export class CredentialsHelper extends ICredentialsHelper {
 	): Promise<ICredentialDataDecryptedObject | undefined> {
 		return undefined;
 	}
-
-	async getCredentials(
-		nodeCredentials: INodeCredentialsDetails,
-		type: string,
-	): Promise<ICredentials> {
-		return new Credentials({ id: null, name: '' }, '', '');
-	}
-
-	async getDecrypted(
-		additionalData: IWorkflowExecuteAdditionalData,
-		nodeCredentials: INodeCredentialsDetails,
-		type: string,
-		mode: WorkflowExecuteMode,
-		executeData?: IExecuteData,
-		raw?: boolean,
-		expressionResolveValues?: ICredentialsExpressionResolveValues,
-	): Promise<ICredentialDataDecryptedObject> {
-		return this.credentials[type];
-	}
-
-	async updateCredentials(
-		nodeCredentials: INodeCredentialsDetails,
-		type: string,
-		data: ICredentialDataDecryptedObject,
-	): Promise<void> {}
-
-	getCredentialsProperties(type: string): INodeProperties[] {
-		return [];
-	}
 }

nodes/ApifyContentCrawler/__tests__/utils/executeWorkflow.ts

@@ -1,74 +1,115 @@
 import {
-	createDeferredPromise,
 	ICredentialsHelper,
-	IExecuteWorkflowInfo,
+	IExecuteFunctions,
+	IExecuteSingleFunctions,
+	INodeExecutionData,
 	IRun,
-	IWorkflowBase,
-	IWorkflowExecuteAdditionalData,
-	LoggerProxy,
-	Workflow,
+	ITaskData,
 } from 'n8n-workflow';
-import { WorkflowExecute, ExecutionLifecycleHooks } from 'n8n-core';
 import { nodeTypes } from './nodeTypesClass';
+import * as fixtures from './fixtures';
 
 export type ExecuteWorkflowArgs = {
 	workflow: any;
 	credentialsHelper: ICredentialsHelper;
 };
 
-export const executeWorkflow = async ({ credentialsHelper, ...args }: ExecuteWorkflowArgs) => {
-	LoggerProxy.init({
-		debug() {},
-		error() {},
-		info() {},
-		warn() {},
-	});
+export const executeWorkflow = async ({
+	credentialsHelper,
+	workflow: workflowJson,
+}: ExecuteWorkflowArgs): Promise<{ executionData: IRun }> => {
+	// Pick the first node (your crawler)
+	const [node] = workflowJson.nodes;
 
-	const workflow = new Workflow({
-		id: 'test',
-		active: true,
-		connections: args.workflow.connections,
-		nodes: args.workflow.nodes,
-		nodeTypes,
-	});
+	// Minimal fake executeFunctions
+	const fakeExecuteFunctions = {
+		getCredentials: async (name: string) => {
+			return credentialsHelper.getDecrypted({} as any, { name } as any, name, 'manual');
+		},
+		getNodeParameter: (parameterName: string) => {
+			return node.parameters[parameterName];
+		},
+		getInputData: (): INodeExecutionData[] => {
+			// Provide at least one empty item so loops like `for (let i = 0; i < items.length; i++)`
+			// still work
+			return [{ json: {} }];
+		},
+		continueOnFail: () => {
+			return false;
+		},
+		getNode: () => {
+			return node;
+		},
+		helpers: {
+			requestWithAuthentication: async function (
+				this: IExecuteFunctions,
+				_credentialType: string,
+				options: any,
+			) {
+				const url = options.url as string;
 
-	const waitPromise = createDeferredPromise<IRun>();
+				if (url.includes('/builds/default')) {
+					return fixtures.getBuildResult();
+				}
+				if (url.includes('/runs')) {
+					return fixtures.runActorResult();
+				}
+				if (url.includes('/actor-runs/')) {
+					return fixtures.getSuccessRunResult();
+				}
+				if (url.includes('/actors/')) {
+					return fixtures.getActorResult();
+				}
+				if (url.includes('/datasets/')) {
+					return fixtures.getDatasetItems();
+				}
 
-	const workflowData: IWorkflowBase = {
-		id: 'test',
-		name: 'test',
-		createdAt: new Date(),
-		updatedAt: new Date(),
-		active: true,
-		nodes: args.workflow.nodes,
-		connections: args.workflow.connections,
-	};
-
-	const additionalData: IWorkflowExecuteAdditionalData = {
-		credentialsHelper,
-		hooks: new ExecutionLifecycleHooks('trigger', '1', workflowData),
-		executeWorkflow: async (workflowInfo: IExecuteWorkflowInfo): Promise<any> => {},
-		restApiUrl: 'http://localhost:5678',
-		webhookBaseUrl: 'http://localhost:5678',
-		webhookWaitingBaseUrl: 'http://localhost:5678',
-		webhookTestBaseUrl: 'http://localhost:5678',
-		userId: 'userId',
-		instanceBaseUrl: 'http://localhost:5678',
-		formWaitingBaseUrl: 'http://localhost:5678',
-		variables: {},
-		secretsHelpers: {} as any,
-		logAiEvent: async () => {},
-		startRunnerTask: (async () => {}) as any,
-	};
+				throw new Error(`Unhandled request in fixture stub: ${url}`);
+			},
+			returnJsonArray: (items: any[]) => {
+				return items.map((i) => ({ json: i }));
+			},
+			constructExecutionMetaData: (inputData: any, _options: any) => {
+				return inputData;
+			},
+		},
+	} as unknown as IExecuteFunctions & IExecuteSingleFunctions;
 
-	const workflowExecute = new WorkflowExecute(additionalData, 'cli');
+	// Run the node directly
+	const nodeType = nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+	if (!('execute' in nodeType) || typeof nodeType.execute !== 'function') {
+		throw new Error(`Node ${node.type} has no execute() method`);
+	}
+	const result = await (nodeType.execute as Function).call(fakeExecuteFunctions);
 
-	const executionData = await workflowExecute.run(workflow);
+	// Build fake ITaskData
+	const taskData: ITaskData = {
+		startTime: Date.now(),
+		executionTime: 1,
+		executionStatus: 'success',
+		data: { main: result as any },
+		source: [
+			{
+				previousNode: '',
+			},
+		],
+	};
 
-	return {
-		workflow,
-		waitPromise,
-		executionData,
-		additionalData,
+	// Wrap in fake IRun-like structure
+	const executionData: IRun = {
+		mode: 'manual',
+		status: 'success',
+		data: {
+			resultData: {
+				runData: {
+					[node.name]: [taskData],
+				},
+			},
+		},
+		finished: true,
+		startedAt: new Date(),
+		stoppedAt: new Date(),
 	};
+
+	return { executionData };
 };