refactor: unify string list parsing logic

Author: MQ37

src/mcp/actors.ts

@@ -3,6 +3,7 @@ import type { ActorDefinition } from 'apify-client';
 import { ApifyClient } from '../apify-client.js';
 import { MCP_STREAMABLE_ENDPOINT } from '../const.js';
 import type { ActorDefinitionPruned } from '../types.js';
+import { parseCommaSeparatedList } from '../utils/generic.js';
 
 /**
  * Returns the MCP server path for the given Actor ID.
@@ -13,7 +14,7 @@ export function getActorMCPServerPath(actorDefinition: ActorDefinition | ActorDe
     if ('webServerMcpPath' in actorDefinition && typeof actorDefinition.webServerMcpPath === 'string') {
         const webServerMcpPath = actorDefinition.webServerMcpPath.trim();
 
-        const paths = webServerMcpPath.split(',').map((path) => path.trim());
+        const paths = parseCommaSeparatedList(webServerMcpPath);
         // If there is only one path, return it directly
         if (paths.length === 1) {
             return paths[0];

src/stdio.ts

@@ -25,6 +25,7 @@ import log from '@apify/log';
 import { processInput } from './input.js';
 import { ActorsMcpServer } from './mcp/server.js';
 import type { Input, ToolSelector } from './types.js';
+import { parseCommaSeparatedList } from './utils/generic.js';
 import { loadToolsFromInput } from './utils/tools-loader.js';
 
 // Keeping this interface here and not types.ts since
@@ -86,13 +87,9 @@ For more details visit https://mcp.apify.com`,
 // Respect either the new flag or the deprecated one
 const enableAddingActors = Boolean(argv.enableAddingActors || argv.enableActorAutoLoading);
 // Split actors argument, trim whitespace, and filter out empty strings
-const actorList = argv.actors !== undefined
-    ? argv.actors.split(',').map((a: string) => a.trim()).filter((a: string) => a.length > 0)
-    : undefined;
+const actorList = argv.actors !== undefined ? parseCommaSeparatedList(argv.actors) : undefined;
 // Split tools argument, trim whitespace, and filter out empty strings
-const toolCategoryKeys = argv.tools !== undefined
-    ? argv.tools.split(',').map((t: string) => t.trim()).filter((t: string) => t.length > 0)
-    : undefined;
+const toolCategoryKeys = argv.tools !== undefined ? parseCommaSeparatedList(argv.tools) : undefined;
 
 // Propagate log.error to console.error for easier debugging
 const originalError = log.error.bind(log);

src/tools/dataset.ts

@@ -5,6 +5,7 @@ import { ApifyClient } from '../apify-client.js';
 import { HelperTools } from '../const.js';
 import type { InternalTool, ToolEntry } from '../types.js';
 import { ajv } from '../utils/ajv.js';
+import { parseCommaSeparatedList } from '../utils/generic.js';
 import { generateSchemaFromItems } from '../utils/schema-generation.js';
 
 const getDatasetArgs = z.object({
@@ -91,9 +92,9 @@ export const getDatasetItems: ToolEntry = {
             const client = new ApifyClient({ token: apifyToken });
 
             // Convert comma-separated strings to arrays
-            const fields = parsed.fields?.split(',').map((f) => f.trim());
-            const omit = parsed.omit?.split(',').map((f) => f.trim());
-            const flatten = parsed.flatten?.split(',').map((f) => f.trim());
+            const fields = parseCommaSeparatedList(parsed.fields);
+            const omit = parseCommaSeparatedList(parsed.omit);
+            const flatten = parseCommaSeparatedList(parsed.flatten);
 
             const v = await client.dataset(parsed.datasetId).listItems({
                 clean: parsed.clean,

src/tools/get-actor-output.ts

@@ -5,7 +5,7 @@ import { ApifyClient } from '../apify-client.js';
 import { HelperTools, TOOL_MAX_OUTPUT_CHARS } from '../const.js';
 import type { InternalTool, ToolEntry } from '../types.js';
 import { ajv } from '../utils/ajv.js';
-import { getValuesByDotKeys } from '../utils/generic.js';
+import { getValuesByDotKeys, parseCommaSeparatedList } from '../utils/generic.js';
 
 /**
  * Zod schema for get-actor-output tool arguments
@@ -78,12 +78,7 @@ You also can retrieve only specific fields from the output if needed. Use this t
             const client = new ApifyClient({ token: apifyToken });
 
             // Parse fields into array
-            const fieldsArray = parsed.fields
-                ? parsed.fields
-                    .split(',')
-                    .map((field) => field.trim())
-                    .filter((field) => field.length > 0)
-                : [];
+            const fieldsArray = parseCommaSeparatedList(parsed.fields);
 
             // TODO: we can optimize the API level field filtering in future
             /**

src/utils/generic.ts

@@ -8,6 +8,23 @@
  * const value = getValuesByDotKeys(obj, ['a.b.c', 'a.b.d', 'nested']);
  * value; // { 'a.b.c': 42, 'a.b.d': undefined, 'nested': { d: 100 } }
  */
+/**
+ * Parses a comma-separated string into an array of trimmed strings.
+ * Empty strings are filtered out after trimming.
+ *
+ * @param input - The comma-separated string to parse. If undefined, returns an empty array.
+ * @returns An array of trimmed, non-empty strings.
+ * @example
+ * parseCommaSeparatedList("a, b, c"); // ["a", "b", "c"]
+ * parseCommaSeparatedList("a, , b"); // ["a", "b"]
+ */
+export function parseCommaSeparatedList(input?: string): string[] {
+    if (!input) {
+        return [];
+    }
+    return input.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
 export function getValuesByDotKeys(obj: Record<string, unknown>, keys: string[]): Record<string, unknown> {
     const result: Record<string, unknown> = {};
     for (const key of keys) {

tests/unit/utils.generic.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { getValuesByDotKeys } from '../../src/utils/generic.js';
+import { getValuesByDotKeys, parseCommaSeparatedList } from '../../src/utils/generic.js';
 
 describe('getValuesByDotKeys', () => {
     it('should get value for a key without dot', () => {
@@ -50,3 +50,35 @@ describe('getValuesByDotKeys', () => {
         expect(result).toEqual({ nested: { a: 1, b: 2 } });
     });
 });
+
+describe('parseCommaSeparatedList', () => {
+    it('should parse comma-separated list with trimming', () => {
+        const result = parseCommaSeparatedList('field1, field2,field3 ');
+        expect(result).toEqual(['field1', 'field2', 'field3']);
+    });
+
+    it('should handle empty input', () => {
+        const result = parseCommaSeparatedList();
+        expect(result).toEqual([]);
+    });
+
+    it('should handle empty string', () => {
+        const result = parseCommaSeparatedList('');
+        expect(result).toEqual([]);
+    });
+
+    it('should filter empty strings', () => {
+        const result = parseCommaSeparatedList(' field1, , field2,,field3 ');
+        expect(result).toEqual(['field1', 'field2', 'field3']);
+    });
+
+    it('should handle only commas and spaces', () => {
+        const result = parseCommaSeparatedList(' ,  , ');
+        expect(result).toEqual([]);
+    });
+
+    it('should handle single item', () => {
+        const result = parseCommaSeparatedList(' single ');
+        expect(result).toEqual(['single']);
+    });
+});