@jackwener/opencli 0.1.1 → 0.2.0

package/src/pipeline/template.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Tests for the pipeline template engine: render, evalExpr, resolvePath.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { render, evalExpr, resolvePath, normalizeEvaluateSource } from './template.js';
+
+describe('resolvePath', () => {
+  it('resolves args path', () => {
+    expect(resolvePath('args.limit', { args: { limit: 20 } })).toBe(20);
+  });
+  it('resolves nested args path', () => {
+    expect(resolvePath('args.query.keyword', { args: { query: { keyword: 'test' } } })).toBe('test');
+  });
+  it('resolves item path', () => {
+    expect(resolvePath('item.title', { item: { title: 'Hello' } })).toBe('Hello');
+  });
+  it('resolves implicit item path (no prefix)', () => {
+    expect(resolvePath('title', { item: { title: 'World' } })).toBe('World');
+  });
+  it('resolves index', () => {
+    expect(resolvePath('index', { index: 5 })).toBe(5);
+  });
+  it('resolves data path', () => {
+    expect(resolvePath('data.items', { data: { items: [1, 2, 3] } })).toEqual([1, 2, 3]);
+  });
+  it('returns null for missing path', () => {
+    expect(resolvePath('args.missing', { args: {} })).toBeUndefined();
+  });
+  it('resolves array index', () => {
+    expect(resolvePath('data.0', { data: ['a', 'b'] })).toBe('a');
+  });
+});
+
+describe('evalExpr', () => {
+  it('evaluates default filter', () => {
+    expect(evalExpr('args.limit | default(20)', { args: {} })).toBe(20);
+  });
+  it('uses actual value over default', () => {
+    expect(evalExpr('args.limit | default(20)', { args: { limit: 10 } })).toBe(10);
+  });
+  it('evaluates string default', () => {
+    expect(evalExpr("args.name | default('unknown')", { args: {} })).toBe('unknown');
+  });
+  it('evaluates arithmetic: index + 1', () => {
+    expect(evalExpr('index + 1', { index: 0 })).toBe(1);
+  });
+  it('evaluates arithmetic: index * 2', () => {
+    expect(evalExpr('index * 2', { index: 5 })).toBe(10);
+  });
+  it('evaluates || fallback', () => {
+    expect(evalExpr("item.name || 'N/A'", { item: {} })).toBe('N/A');
+  });
+  it('evaluates || with truthy left', () => {
+    expect(evalExpr("item.name || 'N/A'", { item: { name: 'Alice' } })).toBe('Alice');
+  });
+  it('resolves simple path', () => {
+    expect(evalExpr('item.title', { item: { title: 'Test' } })).toBe('Test');
+  });
+  it('applies join filter', () => {
+    expect(evalExpr('item.tags | join(,)', { item: { tags: ['a', 'b', 'c'] } })).toBe('a,b,c');
+  });
+  it('applies upper filter', () => {
+    expect(evalExpr('item.name | upper', { item: { name: 'hello' } })).toBe('HELLO');
+  });
+  it('applies lower filter', () => {
+    expect(evalExpr('item.name | lower', { item: { name: 'HELLO' } })).toBe('hello');
+  });
+  it('applies truncate filter', () => {
+    expect(evalExpr('item.text | truncate(5)', { item: { text: 'Hello World!' } })).toBe('Hello...');
+  });
+  it('chains filters', () => {
+    expect(evalExpr('item.name | upper | truncate(3)', { item: { name: 'hello' } })).toBe('HEL...');
+  });
+  it('applies length filter', () => {
+    expect(evalExpr('item.items | length', { item: { items: [1, 2, 3] } })).toBe(3);
+  });
+});
+
+describe('render', () => {
+  it('renders full expression', () => {
+    expect(render('${{ args.limit }}', { args: { limit: 30 } })).toBe(30);
+  });
+  it('renders inline expression in string', () => {
+    expect(render('Hello ${{ item.name }}!', { item: { name: 'World' } })).toBe('Hello World!');
+  });
+  it('renders multiple inline expressions', () => {
+    expect(render('${{ item.first }}-${{ item.second }}', { item: { first: 'X', second: 'Y' } })).toBe('X-Y');
+  });
+  it('returns non-string values as-is', () => {
+    expect(render(42, {})).toBe(42);
+    expect(render(null, {})).toBeNull();
+    expect(render(undefined, {})).toBeUndefined();
+  });
+  it('returns full expression result as native type', () => {
+    expect(render('${{ args.list }}', { args: { list: [1, 2, 3] } })).toEqual([1, 2, 3]);
+  });
+  it('renders URL template', () => {
+    expect(render('https://api.example.com/search?q=${{ args.keyword }}', { args: { keyword: 'test' } })).toBe('https://api.example.com/search?q=test');
+  });
+});
+
+describe('normalizeEvaluateSource', () => {
+  it('wraps bare expression', () => {
+    expect(normalizeEvaluateSource('document.title')).toBe('() => (document.title)');
+  });
+  it('passes through arrow function', () => {
+    expect(normalizeEvaluateSource('() => 42')).toBe('() => 42');
+  });
+  it('passes through async arrow function', () => {
+    const src = 'async () => { return 1; }';
+    expect(normalizeEvaluateSource(src)).toBe(src);
+  });
+  it('passes through named function', () => {
+    const src = 'function foo() { return 1; }';
+    expect(normalizeEvaluateSource(src)).toBe(src);
+  });
+  it('wraps IIFE pattern', () => {
+    const src = '(async () => { return 1; })()';
+    expect(normalizeEvaluateSource(src)).toBe(`() => (${src})`);
+  });
+  it('handles empty string', () => {
+    expect(normalizeEvaluateSource('')).toBe('() => undefined');
+  });
+});

package/src/pipeline/template.ts

@@ -0,0 +1,157 @@
+/**
+ * Pipeline template engine: ${{ ... }} expression rendering.
+ */
+
+export interface RenderContext {
+  args?: Record<string, any>;
+  data?: any;
+  item?: any;
+  index?: number;
+}
+
+export function render(template: any, ctx: RenderContext): any {
+  if (typeof template !== 'string') return template;
+  // Full expression: entire string is a single ${{ ... }}
+  // Use [^}] to prevent matching across }} boundaries (e.g. "${{ a }}-${{ b }}")
+  const fullMatch = template.match(/^\$\{\{\s*([^}]*(?:\}[^}][^}]*)*)\s*\}\}$/);
+  if (fullMatch && !template.includes('}}-') && !template.includes('}}${{')) return evalExpr(fullMatch[1].trim(), ctx);
+  // Check if the entire string is a single expression (no other text around it)
+  const singleExpr = template.match(/^\$\{\{\s*([\s\S]*?)\s*\}\}$/);
+  if (singleExpr) {
+    // Verify it's truly a single expression (no other ${{ inside)
+    const inner = singleExpr[1];
+    if (!inner.includes('${{')) return evalExpr(inner.trim(), ctx);
+  }
+  return template.replace(/\$\{\{\s*(.*?)\s*\}\}/g, (_m, expr) => String(evalExpr(expr.trim(), ctx)));
+}
+
+export function evalExpr(expr: string, ctx: RenderContext): any {
+  const args = ctx.args ?? {};
+  const item = ctx.item ?? {};
+  const data = ctx.data;
+  const index = ctx.index ?? 0;
+
+  // ── Pipe filters: expr | filter1(arg) | filter2 ──
+  // Supports: default(val), join(sep), upper, lower, truncate(n), trim, replace(old,new)
+  if (expr.includes('|') && !expr.includes('||')) {
+    const segments = expr.split('|').map(s => s.trim());
+    const mainExpr = segments[0];
+    let result = resolvePath(mainExpr, { args, item, data, index });
+    for (let i = 1; i < segments.length; i++) {
+      result = applyFilter(segments[i], result);
+    }
+    return result;
+  }
+
+  // Arithmetic: index + 1
+  const arithMatch = expr.match(/^([\w][\w.]*)\s*([+\-*/])\s*(\d+)$/);
+  if (arithMatch) {
+    const [, varName, op, numStr] = arithMatch;
+    const val = resolvePath(varName, { args, item, data, index });
+    if (val !== null && val !== undefined) {
+      const numVal = Number(val); const num = Number(numStr);
+      if (!isNaN(numVal)) {
+        switch (op) {
+          case '+': return numVal + num; case '-': return numVal - num;
+          case '*': return numVal * num; case '/': return num !== 0 ? numVal / num : 0;
+        }
+      }
+    }
+  }
+
+  // JS-like fallback expression: item.tweetCount || 'N/A'
+  const orMatch = expr.match(/^(.+?)\s*\|\|\s*(.+)$/);
+  if (orMatch) {
+    const left = evalExpr(orMatch[1].trim(), ctx);
+    if (left) return left;
+    const right = orMatch[2].trim();
+    return right.replace(/^['"]|['"]$/g, '');
+  }
+
+  return resolvePath(expr, { args, item, data, index });
+}
+
+/**
+ * Apply a named filter to a value.
+ * Supported filters:
+ *   default(val), join(sep), upper, lower, truncate(n), trim,
+ *   replace(old,new), keys, length, first, last
+ */
+function applyFilter(filterExpr: string, value: any): any {
+  const match = filterExpr.match(/^(\w+)(?:\((.+)\))?$/);
+  if (!match) return value;
+  const [, name, rawArgs] = match;
+  const filterArg = rawArgs?.replace(/^['"]|['"]$/g, '') ?? '';
+
+  switch (name) {
+    case 'default': {
+      if (value === null || value === undefined || value === '') {
+        const intVal = parseInt(filterArg, 10);
+        if (!isNaN(intVal) && String(intVal) === filterArg.trim()) return intVal;
+        return filterArg;
+      }
+      return value;
+    }
+    case 'join':
+      return Array.isArray(value) ? value.join(filterArg || ', ') : value;
+    case 'upper':
+      return typeof value === 'string' ? value.toUpperCase() : value;
+    case 'lower':
+      return typeof value === 'string' ? value.toLowerCase() : value;
+    case 'trim':
+      return typeof value === 'string' ? value.trim() : value;
+    case 'truncate': {
+      const n = parseInt(filterArg, 10) || 50;
+      return typeof value === 'string' && value.length > n ? value.slice(0, n) + '...' : value;
+    }
+    case 'replace': {
+      if (typeof value !== 'string') return value;
+      const parts = rawArgs?.split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')) ?? [];
+      return parts.length >= 2 ? value.replaceAll(parts[0], parts[1]) : value;
+    }
+    case 'keys':
+      return value && typeof value === 'object' ? Object.keys(value) : value;
+    case 'length':
+      return Array.isArray(value) ? value.length : typeof value === 'string' ? value.length : value;
+    case 'first':
+      return Array.isArray(value) ? value[0] : value;
+    case 'last':
+      return Array.isArray(value) ? value[value.length - 1] : value;
+    default:
+      return value;
+  }
+}
+
+export function resolvePath(pathStr: string, ctx: RenderContext): any {
+  const args = ctx.args ?? {};
+  const item = ctx.item ?? {};
+  const data = ctx.data;
+  const index = ctx.index ?? 0;
+  const parts = pathStr.split('.');
+  const rootName = parts[0];
+  let obj: any; let rest: string[];
+  if (rootName === 'args') { obj = args; rest = parts.slice(1); }
+  else if (rootName === 'item') { obj = item; rest = parts.slice(1); }
+  else if (rootName === 'data') { obj = data; rest = parts.slice(1); }
+  else if (rootName === 'index') return index;
+  else { obj = item; rest = parts; }
+  for (const part of rest) {
+    if (obj && typeof obj === 'object' && !Array.isArray(obj)) obj = obj[part];
+    else if (Array.isArray(obj) && /^\d+$/.test(part)) obj = obj[parseInt(part, 10)];
+    else return null;
+  }
+  return obj;
+}
+
+/**
+ * Normalize JavaScript source for browser evaluate() calls.
+ */
+export function normalizeEvaluateSource(source: string): string {
+  const stripped = source.trim();
+  if (!stripped) return '() => undefined';
+  if (stripped.startsWith('(') && stripped.endsWith(')()')) return `() => (${stripped})`;
+  if (/^(async\s+)?\([^)]*\)\s*=>/.test(stripped)) return stripped;
+  if (/^(async\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=>/.test(stripped)) return stripped;
+  if (stripped.startsWith('function ') || stripped.startsWith('async function ')) return stripped;
+  return `() => (${stripped})`;
+}

package/src/pipeline/transform.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Tests for pipeline transform steps: select, map, filter, sort, limit.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { stepSelect, stepMap, stepFilter, stepSort, stepLimit } from './steps/transform.js';
+
+const SAMPLE_DATA = [
+  { title: 'Alpha', score: 10, author: 'Alice' },
+  { title: 'Beta', score: 30, author: 'Bob' },
+  { title: 'Gamma', score: 20, author: 'Charlie' },
+];
+
+describe('stepSelect', () => {
+  it('selects nested path', async () => {
+    const data = { result: { items: [1, 2, 3] } };
+    const result = await stepSelect(null, 'result.items', data, {});
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('selects array by index', async () => {
+    const data = { list: ['a', 'b', 'c'] };
+    const result = await stepSelect(null, 'list.1', data, {});
+    expect(result).toBe('b');
+  });
+
+  it('returns null for missing path', async () => {
+    const result = await stepSelect(null, 'missing.path', { foo: 1 }, {});
+    expect(result).toBeNull();
+  });
+
+  it('returns data as-is for non-object', async () => {
+    const result = await stepSelect(null, 'foo', 'string-data', {});
+    expect(result).toBe('string-data');
+  });
+});
+
+describe('stepMap', () => {
+  it('maps array items', async () => {
+    const result = await stepMap(null, {
+      name: '${{ item.title }}',
+      rank: '${{ index + 1 }}',
+    }, SAMPLE_DATA, {});
+    expect(result).toEqual([
+      { name: 'Alpha', rank: 1 },
+      { name: 'Beta', rank: 2 },
+      { name: 'Gamma', rank: 3 },
+    ]);
+  });
+
+  it('handles single object', async () => {
+    const result = await stepMap(null, {
+      name: '${{ item.title }}',
+    }, { title: 'Solo' }, {});
+    expect(result).toEqual([{ name: 'Solo' }]);
+  });
+
+  it('returns null/undefined as-is', async () => {
+    expect(await stepMap(null, { x: '${{ item.x }}' }, null, {})).toBeNull();
+  });
+});
+
+describe('stepFilter', () => {
+  it('filters by expression', async () => {
+    const result = await stepFilter(null, 'item.score', SAMPLE_DATA, {});
+    expect(result).toHaveLength(3); // all truthy
+  });
+
+  it('returns non-array as-is', async () => {
+    const result = await stepFilter(null, 'item.x', 'not-array', {});
+    expect(result).toBe('not-array');
+  });
+});
+
+describe('stepSort', () => {
+  it('sorts ascending by key', async () => {
+    const result = await stepSort(null, 'score', SAMPLE_DATA, {});
+    expect(result.map((r: any) => r.title)).toEqual(['Alpha', 'Gamma', 'Beta']);
+  });
+
+  it('sorts descending', async () => {
+    const result = await stepSort(null, { by: 'score', order: 'desc' }, SAMPLE_DATA, {});
+    expect(result.map((r: any) => r.title)).toEqual(['Beta', 'Gamma', 'Alpha']);
+  });
+
+  it('does not mutate original', async () => {
+    const original = [...SAMPLE_DATA];
+    await stepSort(null, 'score', SAMPLE_DATA, {});
+    expect(SAMPLE_DATA).toEqual(original);
+  });
+});
+
+describe('stepLimit', () => {
+  it('limits array to N items', async () => {
+    const result = await stepLimit(null, '2', SAMPLE_DATA, {});
+    expect(result).toHaveLength(2);
+  });
+
+  it('limits using template expression', async () => {
+    const result = await stepLimit(null, '${{ args.limit }}', SAMPLE_DATA, { limit: 1 });
+    expect(result).toHaveLength(1);
+  });
+
+  it('returns non-array as-is', async () => {
+    expect(await stepLimit(null, '5', 'string', {})).toBe('string');
+  });
+});