@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,128 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import {} from '../NodeGraph.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../ProcessContext.js';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/index.js';
+export class GraphReferenceNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'graphReference',
+            title: 'Graph Reference',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 275,
+            },
+            data: {
+                graphId: '',
+                useGraphIdOrNameInput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [];
+        if (this.data.useGraphIdOrNameInput) {
+            inputs.push({
+                id: 'graph-name-or-id',
+                dataType: 'string',
+                title: 'Graph Name Or ID',
+                description: 'The name or ID of the graph to get a reference to.',
+                required: true,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'graph',
+                dataType: 'graph-reference',
+                title: 'Graph',
+                description: 'A reference to the graph.',
+            },
+        ];
+    }
+    getEditors() {
+        const definitions = [
+            {
+                type: 'graphSelector',
+                label: 'Graph',
+                dataKey: 'graphId',
+                useInputToggleDataKey: 'useGraphIdOrNameInput',
+            },
+        ];
+        return definitions;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Gets a reference to another graph, that can be used to pass around graphs to call using a Call Graph node.
+      `,
+            infoBoxTitle: 'Graph Reference Node',
+            contextMenuTitle: 'Graph Reference',
+            group: ['Advanced'],
+        };
+    }
+    getBody(context) {
+        if (this.data.useGraphIdOrNameInput) {
+            return '(Graph from input)';
+        }
+        const graph = context.project.graphs[this.data.graphId];
+        if (!graph) {
+            return '(Graph not found)';
+        }
+        return graph.metadata.name ?? '(Unnamed Graph)';
+    }
+    async process(inputs, context) {
+        if (this.data.useGraphIdOrNameInput) {
+            const graphIdOrName = coerceType(inputs['graph-name-or-id'], 'string');
+            let graph = context.project.graphs[graphIdOrName];
+            if (!graph) {
+                graph = Object.values(context.project.graphs).find((graph) => graph.metadata.name === graphIdOrName);
+            }
+            if (!graph) {
+                return {
+                    ['graph']: {
+                        type: 'control-flow-excluded',
+                        value: undefined,
+                    },
+                };
+            }
+            return {
+                ['graph']: {
+                    type: 'graph-reference',
+                    value: {
+                        graphId: graph.metadata.id ?? '',
+                        graphName: graph.metadata.name ?? '',
+                    },
+                },
+            };
+        }
+        const graph = context.project.graphs[this.data.graphId];
+        if (!graph) {
+            return {
+                ['graph']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        return {
+            ['graph']: {
+                type: 'graph-reference',
+                value: {
+                    graphId: graph.metadata.id ?? '',
+                    graphName: graph.metadata.name ?? '',
+                },
+            },
+        };
+    }
+}
+export const graphReferenceNode = nodeDefinition(GraphReferenceNodeImpl, 'Graph Reference');

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

@@ -0,0 +1,97 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../../index.js';
+import * as crypto from 'crypto-js';
+import { match } from 'ts-pattern';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/coerceType.js';
+const { SHA256, SHA512, MD5, SHA1 } = crypto;
+export class HashNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'hash',
+            title: 'Hash',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                algorithm: 'sha256',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'input',
+                title: 'Input',
+                dataType: 'string',
+                required: true,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'hash',
+                title: 'Hash',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Algorithm',
+                dataKey: 'algorithm',
+                options: [
+                    { value: 'md5', label: 'MD5' },
+                    { value: 'sha1', label: 'SHA1' },
+                    { value: 'sha256', label: 'SHA256' },
+                    { value: 'sha512', label: 'SHA512' },
+                ],
+            },
+        ];
+    }
+    getBody() {
+        return algorithmDisplayName[this.data.algorithm];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Computes a hash of the input value using the configured hash function.
+      `,
+            infoBoxTitle: 'Hash Node',
+            contextMenuTitle: 'Hash',
+            group: ['Data'],
+        };
+    }
+    async process(inputs) {
+        const inputText = coerceType(inputs['input'], 'string');
+        const hash = match(this.data.algorithm)
+            .with('md5', () => MD5(inputText).toString())
+            .with('sha1', () => SHA1(inputText).toString())
+            .with('sha256', () => SHA256(inputText).toString())
+            .with('sha512', () => SHA512(inputText).toString())
+            .exhaustive();
+        return {
+            ['hash']: {
+                type: 'string',
+                value: hash,
+            },
+        };
+    }
+}
+const algorithmDisplayName = {
+    md5: 'MD5',
+    sha1: 'SHA-1',
+    sha256: 'SHA-256',
+    sha512: 'SHA-512',
+};
+export const hashNode = nodeDefinition(HashNodeImpl, 'Hash');

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

@@ -0,0 +1,257 @@
+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 { coerceType, dedent, getInputOrData } from '../../utils/index.js';
+import { getError } from '../../utils/errors.js';
+export class HttpCallNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'httpCall',
+            title: 'Http Call',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                method: 'GET',
+                url: '',
+                headers: '',
+                body: '',
+                errorOnNon200: true,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [];
+        if (this.data.useMethodInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'method',
+                title: 'Method',
+            });
+        }
+        if (this.data.useUrlInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'url',
+                title: 'URL',
+            });
+        }
+        if (this.data.useHeadersInput) {
+            inputs.push({
+                dataType: 'object',
+                id: 'headers',
+                title: 'Headers',
+            });
+        }
+        if (this.data.useBodyInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'req_body',
+                title: 'Body',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputDefinitions = [];
+        if (this.data.isBinaryOutput) {
+            outputDefinitions.push({
+                dataType: 'binary',
+                id: 'binary',
+                title: 'Binary',
+            });
+        }
+        else {
+            outputDefinitions.push({
+                dataType: 'string',
+                id: 'res_body',
+                title: 'Body',
+            }, {
+                dataType: 'object',
+                id: 'json',
+                title: 'JSON',
+            });
+        }
+        outputDefinitions.push({
+            dataType: 'number',
+            id: 'statusCode',
+            title: 'Status Code',
+        }, {
+            dataType: 'object',
+            id: 'res_headers',
+            title: 'Headers',
+        });
+        return outputDefinitions;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Method',
+                dataKey: 'method',
+                useInputToggleDataKey: 'useMethodInput',
+                options: [
+                    { label: 'GET', value: 'GET' },
+                    { label: 'POST', value: 'POST' },
+                    { label: 'PUT', value: 'PUT' },
+                    { label: 'DELETE', value: 'DELETE' },
+                ],
+            },
+            {
+                type: 'string',
+                label: 'URL',
+                dataKey: 'url',
+                useInputToggleDataKey: 'useUrlInput',
+            },
+            {
+                type: 'code',
+                label: 'Headers',
+                dataKey: 'headers',
+                useInputToggleDataKey: 'useHeadersInput',
+                language: 'json',
+            },
+            {
+                type: 'code',
+                label: 'Body',
+                dataKey: 'body',
+                useInputToggleDataKey: 'useBodyInput',
+                language: 'json',
+            },
+            {
+                type: 'toggle',
+                label: 'Whether response body is expected to be a binary',
+                dataKey: 'isBinaryOutput',
+            },
+            {
+                type: 'toggle',
+                label: 'Error on non-200 status code',
+                dataKey: 'errorOnNon200',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.useMethodInput ? '(Method Using Input)' : this.data.method} ${this.data.useUrlInput ? '(URL Using Input)' : this.data.url} ${this.data.useHeadersInput
+            ? '\nHeaders: (Using Input)'
+            : this.data.headers.trim()
+                ? `\nHeaders: ${this.data.headers}`
+                : ''}${this.data.useBodyInput ? '\nBody: (Using Input)' : this.data.body.trim() ? `\nBody: ${this.data.body}` : ''}${this.data.errorOnNon200 ? '\nError on non-200' : ''}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Makes an HTTP call to the specified URL with the given method, headers, and body.
+      `,
+            infoBoxTitle: 'HTTP Call Node',
+            contextMenuTitle: 'HTTP Call',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        const method = getInputOrData(this.data, inputs, 'method', 'string');
+        const url = getInputOrData(this.data, inputs, 'url', 'string');
+        try {
+            new URL(url);
+        }
+        catch (err) {
+            throw new Error(`Invalid URL: ${url}`);
+        }
+        let headers;
+        if (this.data.useHeadersInput) {
+            const headersInput = inputs['headers'];
+            if (headersInput?.type === 'string') {
+                headers = JSON.parse(headersInput.value);
+            }
+            else if (headersInput?.type === 'object') {
+                headers = headersInput.value;
+            }
+            else {
+                headers = coerceType(headersInput, 'object');
+            }
+        }
+        else if (this.data.headers.trim()) {
+            headers = JSON.parse(this.data.headers);
+        }
+        let body;
+        if (this.data.useBodyInput) {
+            const bodyInput = inputs['req_body'];
+            if (bodyInput?.type === 'string') {
+                body = bodyInput.value;
+            }
+            else if (bodyInput?.type === 'object') {
+                body = JSON.stringify(bodyInput.value);
+            }
+            else {
+                body = coerceType(bodyInput, 'string');
+            }
+        }
+        else {
+            body = this.data.body || undefined;
+        }
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body,
+                signal: context.signal,
+                mode: 'cors',
+            });
+            const output = {
+                ['statusCode']: {
+                    type: 'number',
+                    value: response.status,
+                },
+                ['res_headers']: {
+                    type: 'object',
+                    value: Object.fromEntries(response.headers.entries()),
+                },
+            };
+            if (this.data.isBinaryOutput) {
+                const responseBlob = await response.blob();
+                output['binary'] = {
+                    type: 'binary',
+                    value: new Uint8Array(await responseBlob.arrayBuffer()),
+                };
+            }
+            else {
+                const responseText = await response.text();
+                output['res_body'] = {
+                    type: 'string',
+                    value: responseText,
+                };
+                if (response.headers.get('content-type')?.includes('application/json')) {
+                    const jsonData = JSON.parse(responseText);
+                    output['json'] = {
+                        type: 'object',
+                        value: jsonData,
+                    };
+                }
+                else {
+                    output['json'] = {
+                        type: 'control-flow-excluded',
+                        value: undefined,
+                    };
+                }
+            }
+            return output;
+        }
+        catch (err) {
+            const { message } = getError(err);
+            if (message.includes('Load failed') || message.includes('Failed to fetch')) {
+                if (context.executor === 'browser') {
+                    throw new Error('Failed to make HTTP call. You may be running into CORS problems. Try using the Node executor in the top-right menu.');
+                }
+            }
+            throw err;
+        }
+    }
+}
+export const httpCallNode = nodeDefinition(HttpCallNodeImpl, 'Http Call');

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

@@ -0,0 +1,138 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../NodeBase.js';
+import {} from '../DataValue.js';
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/coerceType.js';
+export class IfElseNodeImpl extends NodeImpl {
+    static create = () => {
+        const chartNode = {
+            type: 'ifElse',
+            title: 'If/Else',
+            id: nanoid(),
+            data: {
+                // Legacy behavior is false
+                unconnectedControlFlowExcluded: true,
+            },
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+        };
+        return chartNode;
+    };
+    getInputDefinitions() {
+        return [
+            {
+                id: 'if',
+                title: 'If',
+                dataType: 'any',
+                description: 'If this is truthy, the `true` value will be passed through the output port. Otherwise, the `false` value will be passed through the output port. An unconnected port is considered false. A `Not Ran` value is considered false.',
+            },
+            {
+                id: 'true',
+                title: 'True',
+                dataType: 'any',
+                description: 'The value to pass through the output port if the condition is truthy. ',
+            },
+            {
+                id: 'false',
+                title: 'False',
+                dataType: 'any',
+                description: 'The value to pass through the output port if the condition is not truthy.',
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'output',
+                title: 'Output',
+                dataType: 'any',
+                description: 'The `true` or `false` value, depending on the `if` condition.',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Takes in three inputs: a condition, a true value, and a false value. If the condition is truthy, the true value is passed through the output port. If the condition is not truthy, the false value is passed through the output port.
+
+        This node can "consume" a \`Not Ran\` to continue a graph from that point.
+      `,
+            infoBoxTitle: 'If/Else Node',
+            contextMenuTitle: 'If/Else',
+            group: ['Logic'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'toggle',
+                label: "Don't run unconnected ports",
+                dataKey: 'unconnectedControlFlowExcluded',
+            },
+        ];
+    }
+    async process(inputData) {
+        const unconnectedValue = this.data.unconnectedControlFlowExcluded
+            ? { type: 'control-flow-excluded', value: undefined }
+            : {
+                type: 'any',
+                value: undefined,
+            };
+        const ifValue = inputData['if'];
+        const trueValue = inputData['true'] ?? unconnectedValue;
+        const falseValue = inputData['false'] ?? unconnectedValue;
+        if (!(trueValue || falseValue)) {
+            return {
+                ['output']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        if (ifValue?.type === 'control-flow-excluded') {
+            return {
+                ['output']: falseValue,
+            };
+        }
+        if (ifValue?.value == null) {
+            return {
+                ['output']: falseValue,
+            };
+        }
+        if (ifValue?.type && ifValue.type === 'boolean') {
+            return {
+                ['output']: ifValue.value ? trueValue : falseValue,
+            };
+        }
+        if (ifValue?.type === 'string') {
+            return {
+                ['output']: ifValue.value.length > 0 ? trueValue : falseValue,
+            };
+        }
+        if (ifValue?.type === 'chat-message') {
+            const asString = coerceType(ifValue, 'string');
+            return {
+                ['output']: asString ? trueValue : falseValue,
+            };
+        }
+        if (ifValue?.type.endsWith('[]')) {
+            return {
+                ['output']: ifValue.value.length > 0 ? trueValue : falseValue,
+            };
+        }
+        if (ifValue?.type === 'any' || ifValue?.type === 'object') {
+            return {
+                ['output']: !!ifValue.value ? trueValue : falseValue,
+            };
+        }
+        return {
+            ['output']: falseValue,
+        };
+    }
+}
+export const ifElseNode = nodeDefinition(IfElseNodeImpl, 'If/Else');