Initial commit: n8n Strike API node

- Add Strike API credentials configuration - Implement Strike node with 9 resources (Account, Balance, Currency Exchange, Deposit, Invoice, Payment, Payment Method, Payout, Rates) - Add comprehensive operation descriptions for all resources - Include CLAUDE.MD documentation - Set up build configuration with TypeScript, ESLint, and Prettier 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
2025-12-10 11:00:38 +01:00
commit 5605b9b49a
8925 changed files with 1417728 additions and 0 deletions
--- a/node_modules/n8n-workflow/dist/cjs/run-execution-data-factory.js
+++ b/node_modules/n8n-workflow/dist/cjs/run-execution-data-factory.js
@ -0,0 +1,122 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createRunExecutionData = createRunExecutionData;
+    exports.createEmptyRunExecutionData = createEmptyRunExecutionData;
+    exports.createErrorExecutionData = createErrorExecutionData;
+    /**
+     * Creates a complete IRunExecutionData object with all properties initialized.
+     * You can pass `executionData: null` and `resultData.runData: null` if you
+     * don't want them initialized.
+     */
+    function createRunExecutionData(options = {}) {
+        return {
+            version: 1,
+            startData: options.startData ?? {},
+            resultData: {
+                error: options.resultData?.error,
+                // @ts-expect-error CAT-752
+                runData: options.resultData?.runData === null ? undefined : (options.resultData?.runData ?? {}),
+                pinData: options.resultData?.pinData,
+                lastNodeExecuted: options.resultData?.lastNodeExecuted,
+                metadata: options.resultData?.metadata,
+            },
+            executionData: options.executionData === null
+                ? undefined
+                : {
+                    contextData: options.executionData?.contextData ?? {},
+                    nodeExecutionStack: options.executionData?.nodeExecutionStack ?? [],
+                    metadata: options.executionData?.metadata ?? {},
+                    waitingExecution: options.executionData?.waitingExecution ?? {},
+                    waitingExecutionSource: options.executionData?.waitingExecutionSource ?? {},
+                    runtimeData: options.executionData?.runtimeData,
+                },
+            parentExecution: options.parentExecution,
+            validateSignature: options.validateSignature,
+            waitTill: options.waitTill,
+            manualData: options.manualData,
+            pushRef: options.pushRef,
+        }; // NOTE: we cast to unknown to avoid manual construction of branded type.
+    }
+    /**
+     * Creates a minimal IRunExecutionData object. It only contains an empty
+     * `runData` field. Used when we are not actually executing a workflow, but
+     * need the run data. E.g. in expression evaluations.
+     */
+    function createEmptyRunExecutionData() {
+        return {
+            version: 1,
+            resultData: {
+                runData: {},
+            },
+        }; // NOTE: we cast to unknown to avoid manual construction of branded type.
+    }
+    /**
+     * Creates an IRunExecutionData object for error execution scenarios.
+     * Used when creating execution records for failed nodes with specific
+     * error data and execution context.
+     *
+     * @param node - The node that failed.
+     * @param error - The error that occurred.
+     */
+    function createErrorExecutionData(node, error) {
+        return {
+            version: 1,
+            startData: {
+                destinationNode: {
+                    nodeName: node.name,
+                    mode: 'inclusive',
+                },
+                runNodeFilter: [node.name],
+            },
+            executionData: {
+                contextData: {},
+                metadata: {},
+                nodeExecutionStack: [
+                    {
+                        node,
+                        data: {
+                            main: [
+                                [
+                                    {
+                                        json: {},
+                                        pairedItem: {
+                                            item: 0,
+                                        },
+                                    },
+                                ],
+                            ],
+                        },
+                        source: null,
+                    },
+                ],
+                waitingExecution: {},
+                waitingExecutionSource: {},
+            },
+            resultData: {
+                runData: {
+                    [node.name]: [
+                        {
+                            startTime: 0,
+                            executionIndex: 0,
+                            executionTime: 0,
+                            error,
+                            source: [],
+                        },
+                    ],
+                },
+                error,
+                lastNodeExecuted: node.name,
+            },
+        }; // NOTE: we cast to unknown to avoid manual construction of branded type.
+    }
+});
+//# sourceMappingURL=run-execution-data-factory.js.map