npm - @testsmith/testblocks - Versions diffs - 0.9.4 → 0.9.7 - Mend

@testsmith/testblocks 0.9.4 → 0.9.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (300) hide show

package/dist/client/index.html CHANGED Viewed

@@ -16,8 +16,8 @@
         overflow: hidden;
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-BLBBQ6Rn.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-qjoPPl9y.css">
+    <script type="module" crossorigin src="/assets/index-CMMJHs_d.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B8OSvcUg.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/core/blocks/api/ApiAssertBodyContainsBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Assert that response body contains expected value.
+ */
+export declare class ApiAssertBodyContainsBlock extends StatementBlock {
+    readonly type = "api_assert_body_contains";
+    readonly category = "API";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that response body contains expected value";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiAssertBodyContainsBlock.js ADDED Viewed

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiAssertBodyContainsBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+const assertions_1 = require("../assertions");
+/**
+ * Assert that response body contains expected value.
+ */
+class ApiAssertBodyContainsBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_assert_body_contains';
+        this.category = 'API';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that response body contains expected value';
+    }
+    getInputs() {
+        return [
+            { name: 'PATH', type: 'field', fieldType: 'text', default: '' },
+            { name: 'VALUE', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const response = (0, utils_1.getLastResponse)(context);
+        const path = params.PATH;
+        const expectedValue = (0, utils_1.resolveVariables)(params.VALUE, context);
+        const actualValue = path ? (0, utils_1.getValueByPath)(response.body, path) : response.body;
+        const actualStr = typeof actualValue === 'string' ? actualValue : JSON.stringify(actualValue);
+        (0, assertions_1.handleAssertion)(context, actualStr.includes(expectedValue), `Expected ${path || 'body'} to contain "${expectedValue}" but got "${actualStr}"`, { stepType: 'api_assert_body_contains', expected: expectedValue, actual: actualStr });
+        context.logger.info(`✓ ${path || 'body'} contains "${expectedValue}"`);
+        return {
+            _summary: `✓ ${path || 'body'} contains "${expectedValue}"`,
+            path: path || 'body',
+            expected: expectedValue,
+            actual: actualStr.substring(0, 100) + (actualStr.length > 100 ? '...' : ''),
+        };
+    }
+}
+exports.ApiAssertBodyContainsBlock = ApiAssertBodyContainsBlock;

package/dist/core/blocks/api/ApiAssertStatusBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Assert that response has expected status code.
+ */
+export declare class ApiAssertStatusBlock extends StatementBlock {
+    readonly type = "api_assert_status";
+    readonly category = "API";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that response has expected status code";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiAssertStatusBlock.js ADDED Viewed

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiAssertStatusBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+const assertions_1 = require("../assertions");
+/**
+ * Assert that response has expected status code.
+ */
+class ApiAssertStatusBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_assert_status';
+        this.category = 'API';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that response has expected status code';
+    }
+    getInputs() {
+        return [
+            { name: 'STATUS', type: 'field', fieldType: 'number', default: 200, required: true },
+        ];
+    }
+    async execute(params, context) {
+        const response = (0, utils_1.getLastResponse)(context);
+        const expectedStatus = params.STATUS;
+        (0, assertions_1.handleAssertion)(context, response.status === expectedStatus, `Expected status ${expectedStatus} but got ${response.status}`, { stepType: 'api_assert_status', expected: expectedStatus, actual: response.status });
+        context.logger.info(`✓ Status is ${expectedStatus}`);
+        return {
+            _summary: `✓ Status ${response.status} === ${expectedStatus}`,
+            expected: expectedStatus,
+            actual: response.status,
+        };
+    }
+}
+exports.ApiAssertStatusBlock = ApiAssertStatusBlock;

package/dist/core/blocks/api/ApiClearHeadersBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Clear all request headers.
+ */
+export declare class ApiClearHeadersBlock extends StatementBlock {
+    readonly type = "api_clear_headers";
+    readonly category = "API";
+    readonly color = "#7B1FA2";
+    readonly tooltip = "Clear all request headers";
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiClearHeadersBlock.js ADDED Viewed

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClearHeadersBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Clear all request headers.
+ */
+class ApiClearHeadersBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_clear_headers';
+        this.category = 'API';
+        this.color = '#7B1FA2';
+        this.tooltip = 'Clear all request headers';
+    }
+    getInputs() {
+        return [];
+    }
+    async execute(_params, context) {
+        context.variables.delete('__requestHeaders');
+        context.logger.info('Cleared all request headers');
+        return { _summary: 'Headers cleared' };
+    }
+}
+exports.ApiClearHeadersBlock = ApiClearHeadersBlock;

package/dist/core/blocks/api/ApiDeleteBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Perform HTTP DELETE request and store response.
+ */
+export declare class ApiDeleteBlock extends StatementBlock {
+    readonly type = "api_delete";
+    readonly category = "API";
+    readonly color = "#4CAF50";
+    readonly tooltip = "Perform HTTP DELETE request and store response";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiDeleteBlock.js ADDED Viewed

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiDeleteBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Perform HTTP DELETE request and store response.
+ */
+class ApiDeleteBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_delete';
+        this.category = 'API';
+        this.color = '#4CAF50';
+        this.tooltip = 'Perform HTTP DELETE request and store response';
+    }
+    getInputs() {
+        return [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'HEADERS', type: 'field', fieldType: 'text', default: '' },
+        ];
+    }
+    async execute(params, context) {
+        const url = (0, utils_1.resolveVariables)(params.URL, context);
+        const headers = (0, utils_1.mergeHeaders)(context, params.HEADERS);
+        context.logger.info(`DELETE ${url}`);
+        const response = await fetch(url, {
+            method: 'DELETE',
+            headers,
+            signal: context.abortSignal,
+        });
+        const parsed = await (0, utils_1.parseResponse)(response);
+        (0, utils_1.storeResponse)(context, parsed);
+        return parsed;
+    }
+}
+exports.ApiDeleteBlock = ApiDeleteBlock;

package/dist/core/blocks/api/ApiExtractBlock.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Extract a value from response using dot notation (e.g., data.user.name).
+ * Legacy block kept for backwards compatibility.
+ */
+export declare class ApiExtractBlock extends StatementBlock {
+    readonly type = "api_extract";
+    readonly category = "API";
+    readonly color = "#2196F3";
+    readonly tooltip = "Extract a value from response using dot notation (e.g., data.user.name)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiExtractBlock.js ADDED Viewed

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExtractBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Extract a value from response using dot notation (e.g., data.user.name).
+ * Legacy block kept for backwards compatibility.
+ */
+class ApiExtractBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_extract';
+        this.category = 'API';
+        this.color = '#2196F3';
+        this.tooltip = 'Extract a value from response using dot notation (e.g., data.user.name)';
+    }
+    getInputs() {
+        return [
+            { name: 'PATH', type: 'field', fieldType: 'text', required: true },
+            { name: 'VARIABLE', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const response = (0, utils_1.getLastResponse)(context);
+        const path = params.PATH;
+        const varName = params.VARIABLE;
+        const value = (0, utils_1.getValueByPath)(response.body, path);
+        context.variables.set(varName, value);
+        const valueStr = JSON.stringify(value);
+        context.logger.info(`Extracted ${path} → ${varName} = ${valueStr}`);
+        return {
+            _summary: `${varName} = ${valueStr.substring(0, 50)}${valueStr.length > 50 ? '...' : ''}`,
+            variable: varName,
+            path,
+            value,
+        };
+    }
+}
+exports.ApiExtractBlock = ApiExtractBlock;

package/dist/core/blocks/api/ApiExtractJsonPathBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Extract a value from JSON response using JSONPath expression.
+ */
+export declare class ApiExtractJsonPathBlock extends StatementBlock {
+    readonly type = "api_extract_jsonpath";
+    readonly category = "API";
+    readonly color = "#2196F3";
+    readonly tooltip = "Extract a value from JSON response using JSONPath expression";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiExtractJsonPathBlock.js ADDED Viewed

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExtractJsonPathBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+const jsonpath_plus_1 = require("jsonpath-plus");
+/**
+ * Extract a value from JSON response using JSONPath expression.
+ */
+class ApiExtractJsonPathBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_extract_jsonpath';
+        this.category = 'API';
+        this.color = '#2196F3';
+        this.tooltip = 'Extract a value from JSON response using JSONPath expression';
+    }
+    getInputs() {
+        return [
+            { name: 'JSONPATH', type: 'field', fieldType: 'text', required: true, default: '$.data.id' },
+            { name: 'VARIABLE', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const response = (0, utils_1.getLastResponse)(context);
+        const jsonPath = params.JSONPATH;
+        const varName = params.VARIABLE;
+        try {
+            const results = (0, jsonpath_plus_1.JSONPath)({ path: jsonPath, json: response.body });
+            // If single result, unwrap from array
+            const value = results.length === 1 ? results[0] : results;
+            context.variables.set(varName, value);
+            const valueStr = JSON.stringify(value);
+            context.logger.info(`Extracted (JSONPath) ${jsonPath} → ${varName} = ${valueStr}`);
+            return {
+                _summary: `${varName} = ${valueStr.substring(0, 50)}${valueStr.length > 50 ? '...' : ''}`,
+                variable: varName,
+                jsonPath,
+                value,
+            };
+        }
+        catch (e) {
+            throw new Error(`Invalid JSONPath expression: ${jsonPath}. Error: ${e.message}`);
+        }
+    }
+}
+exports.ApiExtractJsonPathBlock = ApiExtractJsonPathBlock;

package/dist/core/blocks/api/ApiExtractXPathBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Extract a value from XML/HTML response using XPath expression.
+ */
+export declare class ApiExtractXPathBlock extends StatementBlock {
+    readonly type = "api_extract_xpath";
+    readonly category = "API";
+    readonly color = "#2196F3";
+    readonly tooltip = "Extract a value from XML/HTML response using XPath expression";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiExtractXPathBlock.js ADDED Viewed

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExtractXPathBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+const xpath_1 = __importDefault(require("xpath"));
+const xmldom_1 = require("xmldom");
+/**
+ * Extract a value from XML/HTML response using XPath expression.
+ */
+class ApiExtractXPathBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_extract_xpath';
+        this.category = 'API';
+        this.color = '#2196F3';
+        this.tooltip = 'Extract a value from XML/HTML response using XPath expression';
+    }
+    getInputs() {
+        return [
+            { name: 'XPATH', type: 'field', fieldType: 'text', required: true, default: '//title/text()' },
+            { name: 'VARIABLE', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const response = (0, utils_1.getLastResponse)(context);
+        const xpathExpr = params.XPATH;
+        const varName = params.VARIABLE;
+        try {
+            // Ensure body is a string for XML parsing
+            const xmlString = typeof response.body === 'string'
+                ? response.body
+                : JSON.stringify(response.body);
+            const doc = new xmldom_1.DOMParser().parseFromString(xmlString, 'text/xml');
+            const nodes = xpath_1.default.select(xpathExpr, doc);
+            // Convert nodes to values
+            let value;
+            if (Array.isArray(nodes)) {
+                if (nodes.length === 0) {
+                    value = null;
+                }
+                else if (nodes.length === 1) {
+                    value = (0, utils_1.getNodeValue)(nodes[0]);
+                }
+                else {
+                    value = nodes.map(utils_1.getNodeValue);
+                }
+            }
+            else {
+                value = nodes;
+            }
+            context.variables.set(varName, value);
+            const valueStr = JSON.stringify(value);
+            context.logger.info(`Extracted (XPath) ${xpathExpr} → ${varName} = ${valueStr}`);
+            return {
+                _summary: `${varName} = ${valueStr.substring(0, 50)}${valueStr.length > 50 ? '...' : ''}`,
+                variable: varName,
+                xpath: xpathExpr,
+                value,
+            };
+        }
+        catch (e) {
+            throw new Error(`XPath extraction failed: ${xpathExpr}. Error: ${e.message}`);
+        }
+    }
+}
+exports.ApiExtractXPathBlock = ApiExtractXPathBlock;

package/dist/core/blocks/api/ApiGetBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Perform HTTP GET request and store response.
+ */
+export declare class ApiGetBlock extends StatementBlock {
+    readonly type = "api_get";
+    readonly category = "API";
+    readonly color = "#4CAF50";
+    readonly tooltip = "Perform HTTP GET request and store response";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiGetBlock.js ADDED Viewed

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiGetBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Perform HTTP GET request and store response.
+ */
+class ApiGetBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_get';
+        this.category = 'API';
+        this.color = '#4CAF50';
+        this.tooltip = 'Perform HTTP GET request and store response';
+    }
+    getInputs() {
+        return [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'HEADERS', type: 'field', fieldType: 'text', default: '' },
+        ];
+    }
+    async execute(params, context) {
+        const url = (0, utils_1.resolveVariables)(params.URL, context);
+        const headers = (0, utils_1.mergeHeaders)(context, params.HEADERS);
+        context.logger.info(`GET ${url}`);
+        const response = await fetch(url, {
+            headers,
+            signal: context.abortSignal,
+        });
+        const parsed = await (0, utils_1.parseResponse)(response);
+        (0, utils_1.storeResponse)(context, parsed);
+        return parsed;
+    }
+}
+exports.ApiGetBlock = ApiGetBlock;

package/dist/core/blocks/api/ApiHeadersBlock.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Create a headers object.
+ */
+export declare class ApiHeadersBlock extends ValueBlock {
+    readonly type = "api_headers";
+    readonly category = "API";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Create a headers object";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiHeadersBlock.js ADDED Viewed

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiHeadersBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Create a headers object.
+ */
+class ApiHeadersBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_headers';
+        this.category = 'API';
+        this.color = '#9C27B0';
+        this.tooltip = 'Create a headers object';
+        this.output = { type: 'Object' };
+    }
+    getInputs() {
+        return [
+            { name: 'AUTH_TYPE', type: 'field', fieldType: 'dropdown', options: [['None', 'none'], ['Bearer Token', 'bearer'], ['Basic Auth', 'basic'], ['API Key', 'apikey']] },
+            { name: 'AUTH_VALUE', type: 'field', fieldType: 'text' },
+            { name: 'CUSTOM', type: 'value', check: 'Object' },
+        ];
+    }
+    async execute(params, context) {
+        const authType = params.AUTH_TYPE;
+        const authValue = (0, utils_1.resolveVariables)(params.AUTH_VALUE || '', context);
+        const custom = params.CUSTOM || {};
+        const headers = { ...custom };
+        switch (authType) {
+            case 'bearer':
+                headers['Authorization'] = `Bearer ${authValue}`;
+                break;
+            case 'basic':
+                headers['Authorization'] = `Basic ${Buffer.from(authValue).toString('base64')}`;
+                break;
+            case 'apikey':
+                headers['X-API-Key'] = authValue;
+                break;
+        }
+        return headers;
+    }
+}
+exports.ApiHeadersBlock = ApiHeadersBlock;

package/dist/core/blocks/api/ApiJsonBodyBlock.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Create a JSON body from key-value pairs or raw JSON.
+ */
+export declare class ApiJsonBodyBlock extends ValueBlock {
+    readonly type = "api_json_body";
+    readonly category = "API";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Create a JSON body from key-value pairs or raw JSON";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiJsonBodyBlock.js ADDED Viewed

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiJsonBodyBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Create a JSON body from key-value pairs or raw JSON.
+ */
+class ApiJsonBodyBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_json_body';
+        this.category = 'API';
+        this.color = '#9C27B0';
+        this.tooltip = 'Create a JSON body from key-value pairs or raw JSON';
+        this.output = { type: 'Object' };
+    }
+    getInputs() {
+        return [
+            { name: 'JSON', type: 'field', fieldType: 'text', default: '{}' },
+        ];
+    }
+    async execute(params, context) {
+        const json = (0, utils_1.resolveVariables)(params.JSON, context);
+        return JSON.parse(json);
+    }
+}
+exports.ApiJsonBodyBlock = ApiJsonBodyBlock;

package/dist/core/blocks/api/ApiPatchBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Perform HTTP PATCH request and store response.
+ */
+export declare class ApiPatchBlock extends StatementBlock {
+    readonly type = "api_patch";
+    readonly category = "API";
+    readonly color = "#4CAF50";
+    readonly tooltip = "Perform HTTP PATCH request and store response";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiPatchBlock.js ADDED Viewed

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPatchBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Perform HTTP PATCH request and store response.
+ */
+class ApiPatchBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_patch';
+        this.category = 'API';
+        this.color = '#4CAF50';
+        this.tooltip = 'Perform HTTP PATCH request and store response';
+    }
+    getInputs() {
+        return [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'BODY', type: 'field', fieldType: 'text', default: '{}' },
+            { name: 'HEADERS', type: 'field', fieldType: 'text', default: '' },
+        ];
+    }
+    async execute(params, context) {
+        const url = (0, utils_1.resolveVariables)(params.URL, context);
+        const bodyStr = (0, utils_1.resolveVariables)(params.BODY || '{}', context);
+        const inlineHeaders = (0, utils_1.mergeHeaders)(context, params.HEADERS);
+        let body;
+        try {
+            body = JSON.parse(bodyStr);
+        }
+        catch {
+            body = bodyStr;
+        }
+        context.logger.info(`PATCH ${url}`);
+        const response = await fetch(url, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json', ...inlineHeaders },
+            body: typeof body === 'string' ? body : JSON.stringify(body),
+            signal: context.abortSignal,
+        });
+        const parsed = await (0, utils_1.parseResponse)(response);
+        (0, utils_1.storeResponse)(context, parsed);
+        return parsed;
+    }
+}
+exports.ApiPatchBlock = ApiPatchBlock;

package/dist/core/blocks/api/ApiPostBlock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Perform HTTP POST request and store response.
+ */
+export declare class ApiPostBlock extends StatementBlock {
+    readonly type = "api_post";
+    readonly category = "API";
+    readonly color = "#4CAF50";
+    readonly tooltip = "Perform HTTP POST request and store response";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}