@jackwener/opencli 0.1.1 → 0.1.2

package/src/pipeline/template.ts

@@ -0,0 +1,101 @@
+/**
+ * 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;
+  const fullMatch = template.match(/^\$\{\{\s*(.*?)\s*\}\}$/);
+  if (fullMatch) return evalExpr(fullMatch[1].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;
+
+  // Default filter: args.limit | default(20)
+  if (expr.includes('|') && expr.includes('default(')) {
+    const [mainExpr, rest] = expr.split('|', 2);
+    const defaultMatch = rest.match(/default\((.+?)\)/);
+    const defaultVal = defaultMatch ? defaultMatch[1] : null;
+    const result = resolvePath(mainExpr.trim(), { args, item, data, index });
+    if (result === null || result === undefined) {
+      if (defaultVal !== null) {
+        const intVal = parseInt(defaultVal!, 10);
+        if (!isNaN(intVal) && String(intVal) === defaultVal!.trim()) return intVal;
+        return defaultVal!.replace(/^['"]|['"]$/g, '');
+      }
+    }
+    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 });
+}
+
+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');
+  });
+});