yaak/plugins/template-function-json/src/index.ts

import type { XPathResult } from '@yaak/template-function-xml';
import type { CallTemplateFunctionArgs, Context, PluginDefinition } from '@yaakapp/api';
import { JSONPath } from 'jsonpath-plus';

const RETURN_FIRST = 'first';
const RETURN_ALL = 'all';
const RETURN_JOIN = 'join';

export const plugin: PluginDefinition = {
  templateFunctions: [
    {
      name: 'json.jsonpath',
      description: 'Filter JSON-formatted text using JSONPath syntax',
      previewArgs: ['query'],
      args: [
        {
          type: 'editor',
          name: 'input',
          label: 'Input',
          language: 'json',
          placeholder: '{ "foo": "bar" }',
        },
        {
          type: 'h_stack',
          inputs: [
            {
              type: 'select',
              name: 'result',
              label: 'Return Format',
              defaultValue: RETURN_FIRST,
              options: [
                { label: 'First result', value: RETURN_FIRST },
                { label: 'All results', value: RETURN_ALL },
                { label: 'Join with separator', value: RETURN_JOIN },
              ],
            },
            {
              name: 'join',
              type: 'text',
              label: 'Separator',
              optional: true,
              defaultValue: ', ',
              dynamic(_ctx, args) {
                return { hidden: args.values.result !== RETURN_JOIN };
              },
            },
          ],
        },
        {
          type: 'checkbox',
          name: 'formatted',
          label: 'Pretty Print',
          description: 'Format the output as JSON',
          dynamic(_ctx, args) {
            return { hidden: args.values.result === RETURN_JOIN };
          },
        },
        { type: 'text', name: 'query', label: 'Query', placeholder: '$..foo' },
      ],
      async onRender(_ctx: Context, args: CallTemplateFunctionArgs): Promise<string | null> {
        try {
          return filterJSONPath(
            String(args.values.input),
            String(args.values.query),
            (args.values.result || RETURN_FIRST) as XPathResult,
            args.values.join == null ? null : String(args.values.join),
            Boolean(args.values.formatted),
          );
        } catch {
          return null;
        }
      },
    },
    {
      name: 'json.escape',
      description: 'Escape a JSON string, useful when using the output in JSON values',
      args: [
        {
          type: 'text',
          name: 'input',
          label: 'Input',
          multiLine: true,
          placeholder: 'Hello "World"',
        },
      ],
      async onRender(_ctx: Context, args: CallTemplateFunctionArgs): Promise<string | null> {
        const input = String(args.values.input ?? '');
        return input.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
      },
    },
    {
      name: 'json.minify',
      description: 'Remove unnecessary whitespace from a valid JSON string.',
      args: [
        {
          type: 'editor',
          language: 'json',
          name: 'input',
          label: 'Input',
          placeholder: '{ "foo": "bar" }',
        },
      ],
      async onRender(_ctx: Context, args: CallTemplateFunctionArgs): Promise<string | null> {
        const input = String(args.values.input ?? '');
        try {
          return JSON.stringify(JSON.parse(input));
        } catch {
          return input;
        }
      },
    },
  ],
};

export type JSONPathResult = 'first' | 'join' | 'all';

export function filterJSONPath(
  body: string,
  path: string,
  result: JSONPathResult,
  join: string | null,
  formatted = false,
): string {
  const parsed = JSON.parse(body);
  let items = JSONPath({ path, json: parsed });

  if (items == null) {
    return '';
  }

  if (!Array.isArray(items)) {
    // Already good
  } else if (result === 'first') {
    items = items[0] ?? '';
  } else if (result === 'join') {
    items = items.map((i) => objToStr(i, false)).join(join ?? '');
  }

  return objToStr(items, formatted);
}

function objToStr(o: unknown, formatted = false): string {
  if (
    Object.prototype.toString.call(o) === '[object Array]' ||
    Object.prototype.toString.call(o) === '[object Object]'
  ) {
    return formatted ? JSON.stringify(o, null, 2) : JSON.stringify(o);
  }
  return String(o);
}