@alpic80/rivet-core 1.19.1-aidon.1

package/dist/esm/model/nodes/ExtractRegexNode.js

@@ -0,0 +1,201 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../DataValue.js';
+import { expectType, expectTypeOptional } from '../../utils/expectType.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+export class ExtractRegexNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'extractRegex',
+            title: 'Extract Regex',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                regex: '([a-zA-Z]+)',
+                useRegexInput: false,
+                errorOnFailed: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                id: 'input',
+                title: 'Input',
+                dataType: 'string',
+                required: true,
+                coerced: false,
+            },
+        ];
+        if (this.chartNode.data.useRegexInput) {
+            inputs.push({
+                id: 'regex',
+                title: 'Regex',
+                dataType: 'string',
+                required: false,
+                coerced: false,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const regex = this.chartNode.data.regex;
+        try {
+            const regExp = new RegExp(regex, 'g');
+            const captureGroupCount = countCaptureGroups(regExp);
+            const outputs = [];
+            for (let i = 0; i < captureGroupCount; i++) {
+                outputs.push({
+                    id: `output${i + 1}`,
+                    title: `Output ${i + 1}`,
+                    dataType: 'string',
+                });
+            }
+            outputs.push({
+                id: 'matches',
+                title: 'Matches',
+                dataType: 'string[]',
+            });
+            outputs.push({
+                id: 'succeeded',
+                title: 'Succeeded',
+                dataType: 'boolean',
+            }, {
+                id: 'failed',
+                title: 'Failed',
+                dataType: 'boolean',
+            });
+            return outputs;
+        }
+        catch (err) {
+            return [];
+        }
+    }
+    getEditors() {
+        return [
+            {
+                type: 'custom',
+                customEditorId: 'ExtractRegexNodeAiAssist',
+                label: 'AI Assist',
+            },
+            {
+                type: 'toggle',
+                label: 'Error on failed',
+                dataKey: 'errorOnFailed',
+            },
+            {
+                type: 'toggle',
+                label: 'Multiline mode',
+                dataKey: 'multilineMode',
+            },
+            {
+                type: 'code',
+                label: 'Regex',
+                dataKey: 'regex',
+                useInputToggleDataKey: 'useRegexInput',
+                language: 'regex',
+            },
+        ];
+    }
+    getBody() {
+        return this.data.useRegexInput ? '(Using regex input)' : this.data.regex;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Extracts data from the input text using the configured regular expression. The regular expression can contain capture groups to extract specific parts of the text.
+
+        Each capture group corresponds to an output port of the node.
+      `,
+            infoBoxTitle: 'Extract With Regex Node',
+            contextMenuTitle: 'Extract With Regex',
+            group: ['Text'],
+        };
+    }
+    async process(inputs) {
+        const inputString = expectType(inputs['input'], 'string');
+        const regex = expectTypeOptional(inputs['regex'], 'string') ?? this.chartNode.data.regex;
+        const regExp = new RegExp(regex, this.data.multilineMode ? 'gm' : 'g');
+        let matches = [];
+        let match;
+        let firstMatch;
+        while ((match = regExp.exec(inputString)) !== null) {
+            if (!firstMatch) {
+                firstMatch = match;
+            }
+            matches.push(match[1]);
+        }
+        matches = matches.filter((m) => m);
+        if (matches.length === 0 && this.chartNode.data.errorOnFailed) {
+            throw new Error(`No match found for regex ${regex}`);
+        }
+        const outputArray = {
+            type: 'string[]',
+            value: matches,
+        };
+        if (!firstMatch) {
+            if (this.chartNode.data.errorOnFailed) {
+                throw new Error(`No match found for regex ${regex}`);
+            }
+            return {
+                ['succeeded']: {
+                    type: 'boolean',
+                    value: false,
+                },
+                ['failed']: {
+                    type: 'boolean',
+                    value: true,
+                },
+            };
+        }
+        const output = {
+            ['succeeded']: {
+                type: 'boolean',
+                value: true,
+            },
+            ['failed']: {
+                type: 'boolean',
+                value: false,
+            },
+        };
+        output['matches'] = outputArray;
+        for (let i = 1; i < firstMatch.length; i++) {
+            output[`output${i}`] = {
+                type: 'string',
+                value: firstMatch[i],
+            };
+        }
+        return output;
+    }
+}
+function countCaptureGroups(regex) {
+    const regexSource = regex.source;
+    let count = 0;
+    let inCharacterClass = false;
+    for (let i = 0; i < regexSource.length; i++) {
+        const currentChar = regexSource[i];
+        const prevChar = i > 0 ? regexSource[i - 1] : null;
+        if (currentChar === '[' && prevChar !== '\\') {
+            inCharacterClass = true;
+        }
+        else if (currentChar === ']' && prevChar !== '\\') {
+            inCharacterClass = false;
+        }
+        else if (currentChar === '(' && prevChar !== '\\' && !inCharacterClass) {
+            if (regexSource[i + 1] !== '?' || regexSource[i + 2] === ':') {
+                count++;
+            }
+        }
+    }
+    return count;
+}
+export const extractRegexNode = nodeDefinition(ExtractRegexNodeImpl, 'Extract Regex');

package/dist/esm/model/nodes/ExtractYamlNode.js

@@ -0,0 +1,214 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../DataValue.js';
+import yaml from 'yaml';
+import { expectType } from '../../utils/expectType.js';
+import { JSONPath } from 'jsonpath-plus';
+import { dedent } from 'ts-dedent';
+import {} from '../../index.js';
+import { coerceType } from '../../utils/coerceType.js';
+export class ExtractYamlNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'extractYaml',
+            title: 'Extract YAML',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                rootPropertyName: 'yamlDocument',
+                useRootPropertyNameInput: false,
+                useObjectPathInput: false,
+                objectPath: undefined,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                id: 'input',
+                title: 'Input',
+                dataType: 'string',
+                required: true,
+                coerced: false,
+            },
+        ];
+        if (this.data.useRootPropertyNameInput) {
+            inputs.push({
+                id: 'rootPropertyName',
+                title: 'Root Property Name',
+                dataType: 'string',
+                required: true,
+            });
+        }
+        if (this.data.useObjectPathInput) {
+            inputs.push({
+                id: 'objectPath',
+                title: 'Object Path',
+                dataType: 'string',
+                required: true,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'output',
+                title: 'Output',
+                dataType: 'object',
+            },
+            {
+                id: 'matches',
+                title: 'Matches',
+                dataType: 'any[]',
+            },
+            {
+                id: 'noMatch',
+                title: 'No Match',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Root Property Name',
+                dataKey: 'rootPropertyName',
+                useInputToggleDataKey: 'useRootPropertyNameInput',
+            },
+            {
+                type: 'code',
+                label: 'Object Path',
+                dataKey: 'objectPath',
+                language: 'jsonpath',
+                useInputToggleDataKey: 'useObjectPathInput',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Root: ${this.data.useRootPropertyNameInput ? '(Using Input)' : this.data.rootPropertyName}
+      ${this.data.useObjectPathInput
+            ? 'Path: (Using Input)'
+            : this.data.objectPath
+                ? `Path: ${this.data.objectPath}`
+                : ``}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Finds and parses a YAML object in the input text with a predefined root property name (configurable).
+
+        Defaults to \`yamlDocument\`, which means the input text must have a \`yamlDocument:\` root node somewhere in it. All indented text after that is considered part of the YAML.
+
+        Outputs the parsed object.
+      `,
+            infoBoxTitle: 'Extract YAML Node',
+            contextMenuTitle: 'Extract YAML',
+            group: ['Objects'],
+        };
+    }
+    async process(inputs) {
+        const inputString = expectType(inputs['input'], 'string');
+        const rootPropertyName = this.data.useRootPropertyNameInput
+            ? coerceType(inputs['rootPropertyName'], 'string')
+            : this.data.rootPropertyName;
+        const objectPath = this.data.useObjectPathInput
+            ? coerceType(inputs['objectPath'], 'string')
+            : this.data.objectPath;
+        const match = new RegExp(`^${rootPropertyName}:`, 'm').exec(inputString);
+        const rootPropertyStart = match?.index ?? -1;
+        const nextLines = inputString.slice(rootPropertyStart).split('\n');
+        const yamlLines = [nextLines.shift()]; // remove the first line, which is the root property name
+        while (nextLines[0]?.startsWith(' ') || nextLines[0]?.startsWith('\t') || nextLines[0] === '') {
+            yamlLines.push(nextLines.shift());
+        }
+        const potentialYaml = yamlLines.join('\n');
+        let yamlObject = undefined;
+        try {
+            yamlObject = yaml.parse(potentialYaml);
+        }
+        catch (err) {
+            return {
+                ['noMatch']: {
+                    type: 'string',
+                    value: potentialYaml,
+                },
+                ['output']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        if (!yamlObject?.hasOwnProperty(rootPropertyName)) {
+            return {
+                ['noMatch']: {
+                    type: 'string',
+                    value: potentialYaml,
+                },
+                ['output']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        let matches = [];
+        if (objectPath) {
+            try {
+                const extractedValue = JSONPath({ json: yamlObject, path: objectPath.trim() });
+                matches = extractedValue;
+                yamlObject = extractedValue.length > 0 ? extractedValue[0] : undefined;
+            }
+            catch (err) {
+                return {
+                    ['noMatch']: {
+                        type: 'string',
+                        value: potentialYaml,
+                    },
+                    ['output']: {
+                        type: 'control-flow-excluded',
+                        value: undefined,
+                    },
+                    ['matches']: {
+                        type: 'control-flow-excluded',
+                        value: undefined,
+                    },
+                };
+            }
+        }
+        return {
+            ['output']: yamlObject === undefined
+                ? {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                }
+                : this.data.objectPath
+                    ? {
+                        type: 'any',
+                        value: yamlObject,
+                    }
+                    : {
+                        type: 'object',
+                        value: yamlObject,
+                    },
+            ['noMatch']: {
+                type: 'control-flow-excluded',
+                value: undefined,
+            },
+            ['matches']: {
+                type: 'any[]',
+                value: matches,
+            },
+        };
+    }
+}
+export const extractYamlNode = nodeDefinition(ExtractYamlNodeImpl, 'Extract YAML');

package/dist/esm/model/nodes/FilterNode.js

@@ -0,0 +1,73 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import {} from '../../index.js';
+import { zip } from 'lodash-es';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/coerceType.js';
+export class FilterNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'filter',
+            title: 'Filter',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+            data: {},
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'array',
+                title: 'Array',
+                dataType: 'any[]',
+                required: true,
+            },
+            {
+                id: 'include',
+                title: 'Include',
+                dataType: 'boolean[]',
+                required: true,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'filtered',
+                title: 'Filtered',
+                dataType: 'any[]',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Takes in both an array of values, and an array of booleans of the same length, and filters the array where the corresponding boolean is true.
+      `,
+            infoBoxTitle: 'Filter Node',
+            contextMenuTitle: 'Filter',
+            group: ['Lists'],
+        };
+    }
+    async process(inputs) {
+        const array = coerceType(inputs['array'], 'any[]');
+        const include = coerceType(inputs['include'], 'boolean[]');
+        const zipped = zip(array, include);
+        const filtered = zipped.filter(([_, include]) => include).map(([value, _]) => value);
+        return {
+            ['filtered']: {
+                type: inputs['array']?.type ?? 'any',
+                value: filtered,
+            },
+        };
+    }
+}
+export const filterNode = nodeDefinition(FilterNodeImpl, 'Filter');

package/dist/esm/model/nodes/GetAllDatasetsNode.js

@@ -0,0 +1,53 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { dedent, newId } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class GetAllDatasetsNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: newId(),
+            type: 'getAllDatasets',
+            title: 'Get All Datasets',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {},
+        };
+    }
+    getInputDefinitions() {
+        return [];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'datasets',
+                title: 'Datasets',
+                dataType: 'object[]',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Retrieves all datasets. If no datasets exist, it returns an empty array.
+      `,
+            infoBoxTitle: 'Get All Datasets Node',
+            contextMenuTitle: 'Get All Datasets',
+            group: ['Input/Output'],
+        };
+    }
+    getEditors() {
+        return [];
+    }
+    async process(inputs, context) {
+        const { datasetProvider } = context;
+        if (datasetProvider == null) {
+            throw new Error('datasetProvider is required');
+        }
+        const datasets = await datasetProvider.getDatasetsForProject(context.project.metadata.id);
+        return {
+            ['datasets']: {
+                type: 'object[]',
+                value: datasets,
+            },
+        };
+    }
+}
+export const getAllDatasetsNode = nodeDefinition(GetAllDatasetsNodeImpl, 'Get All Datasets');

package/dist/esm/model/nodes/GetDatasetRowNode.js

@@ -0,0 +1,99 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { dedent, getInputOrData, newId } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class GetDatasetRowNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: newId(),
+            type: 'getDatasetRow',
+            title: 'Get Dataset Row',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                datasetId: '',
+                rowId: '',
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputs = [];
+        if (this.data.useRowIdInput) {
+            inputs.push({
+                id: 'rowId',
+                title: 'Row ID',
+                dataType: 'string',
+            });
+        }
+        if (this.data.useDatasetIdInput) {
+            inputs.push({
+                id: 'datasetId',
+                title: 'Dataset ID',
+                dataType: 'string',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'row',
+                title: 'Row',
+                dataType: 'object',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Gets a row from a dataset with the provided ID. If the dataset or row does not exist, it throws an error.
+      `,
+            infoBoxTitle: 'Get Dataset Row Node',
+            contextMenuTitle: 'Get Dataset Row',
+            group: ['Input/Output'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'datasetSelector',
+                label: 'Dataset',
+                dataKey: 'datasetId',
+                useInputToggleDataKey: 'useDatasetIdInput',
+            },
+            {
+                type: 'string',
+                label: 'Row ID',
+                dataKey: 'rowId',
+                useInputToggleDataKey: 'useRowIdInput',
+            },
+        ];
+    }
+    async process(inputs, context) {
+        const { datasetProvider } = context;
+        if (datasetProvider == null) {
+            throw new Error('datasetProvider is required');
+        }
+        const datasetId = getInputOrData(this.data, inputs, 'datasetId', 'string');
+        const rowId = getInputOrData(this.data, inputs, 'rowId', 'string');
+        const dataset = await datasetProvider.getDatasetData(datasetId);
+        if (!dataset) {
+            throw new Error(`Dataset with ID ${datasetId} does not exist`);
+        }
+        // TODO be more efficient
+        const row = dataset.rows.find((r) => r.id === rowId);
+        if (!row) {
+            return {
+                ['row']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        return {
+            ['row']: {
+                type: 'object',
+                value: row,
+            },
+        };
+    }
+}
+export const getDatasetRowNode = nodeDefinition(GetDatasetRowNodeImpl, 'Get Dataset Row');